tło

Kiedy byłem w szkole podstawowej, graliśmy w grę z matematyki, która wygląda następująco.

Wszystkie dzieci siedzą w dużym kręgu i liczą na zmianę, zaczynając od 1 .

Podczas liczenia należy jednak pominąć następujące liczby:

• Liczby będące wielokrotnościami 3 .
• Liczby, które mają 3 w postaci dziesiętnej.

Pierwsze 15 liczb, które dzieci powinny powiedzieć, to

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

Ilekroć ktoś pomyli liczbę - mówi liczbę, która nie jest w sekwencji lub pomija liczbę, która jest - jest usuwany z kręgu. Trwa to dopóki nie zostanie tylko jedno dziecko.

Zadanie

Jesteś zły w tej grze, więc decydujesz się oszukiwać. Napisz program lub funkcję, która na podstawie numeru sekwencji oblicza następny numer sekwencji.

Nie musisz obsługiwać liczb, które nie mogą być reprezentowane przy użyciu rodzimego typu liczbowego twojego języka, pod warunkiem, że twój program działa poprawnie do wejścia 251 i że twój algorytm działa dla dowolnie dużych danych wejściowych.

Wejście i wyjście może wykorzystywać dowolną dogodną bazę.

Ponieważ musisz ukryć swój kod, musi on być jak najkrótszy. W rzeczywistości jest to kod-golf , więc wygrywa najkrótszy kod w bajtach.

Przypadki testowe

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

Brachylog , 10 bajtów

<.='e3:I'*

Wypróbuj online!

Wyjaśnienie

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

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

J, 24 bajty

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

Proste podejście, które po prostu iteruje od wejścia n, aż znajdzie kolejną liczbę, która jest zgodna z regułami.

Formy pięć emotikony, $:, :), 0=, =|, i >:.

Stosowanie

   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

Wyjaśnienie

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 bajty

Dzięki xnor za poinformowanie mnie, że jestem głupi, używając 2 zmiennych, a także dzięki Mitchowi Schwartzowi.

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

05AB1E , 11 bajtów

[>Ð3ås3Ö~_#

Wypróbuj online!

Wyjaśnienie

               # 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 bajtów

Kod 18 bajtów + 1 dla -p.

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

Stosowanie

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

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

Java 8, 57 56 55 50 bajtów

Dzięki @Numberknot za 1 bajt Dzięki @Kevin Cruijssen za 5 bajtów

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

To jest Function<Integer, Integer>

Wyjaśnienie

Naiwne wdrożenie, które po prostu rośnie, aż osiągnie akceptowalną liczbę.

Klasa testowa

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

}

Wynik klasy testowej:

1 2 4 5 7 8 10 11 14 16

Japt, 18 bajtów

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

Przetestuj online

Nareszcie mam szansę skorzystać ß:-)

Jak to działa

                    // 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 bajtów

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

Bierze dane wejściowe $args[0], dodaje 1, zapisuje $a, rozpoczyna forpętlę. Warunkowe utrzymuje pętlę, podczas gdy jedno z nich $a-match3(dopasowanie wyrażenia regularnego) -or $a%3wynosi zero ( !z czego jest 1). Pętla po prostu zwiększa się $a++. Na końcu pętli po prostu umieszczamy $aw potoku, a dane wyjściowe za pośrednictwem niejawnego mają Write-Outputmiejsce po zakończeniu programu.

Przykłady

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 bajtów

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

Python 2, 49 44 42 bajtów

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

Drugi wpis w Pythonie bije to (edytuj: już nie :-D), ale opublikowałem go, ponieważ wolę podejście rekurencyjne. Dzięki Mitchowi Schwarzowi i Erikowi Golferowi za pomoc w skróceniu tego.

Lua, 58 bajtów

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

Pyke, 13 bajtów

Whii3%!3`i`{|

Wypróbuj tutaj!

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

C #, 56 , 51 bajtów.

Jest to zaskakująco krótko jak na odpowiedź w języku C #!

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

Haskell, 50 48 bajtów

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

Wypróbuj na Ideone. Zaoszczędź 2 bajty dzięki @Charlie Harding .

Alternatywnie: (50 bajtów)

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

Pyth, 11 bajtów

f&-I`T3%T3h

Wypróbuj online: pakiet demonstracyjny lub testowy

Wyjaśnienie:

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 bajty

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

Ruby, 47 bajtów

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

Naprawdę czuję, że można dalej grać w golfa.

MATL , 14 bajtów

`Qtt3\wV51-hA~

Wypróbuj online!

Wyjaśnienie

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

Labirynt , 117 102 bajtów

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

Wypróbuj online!

Labirynt jest dwuwymiarowym językiem programowania opartym na stosie, a na skrzyżowaniach kierunek określa góra stosu (dodatni idzie w prawo, ujemny idzie w lewo, zero idzie prosto). W tych programach są dwie główne pętle. Pierwsza modyfikuje wprowadzoną liczbę całkowitą o 3 i zwiększa ją o 0. Druga wielokrotnie sprawdza, czy ostatnia cyfra to 3 (odejmując 3 i modując przez 10), a następnie dzieląc przez 10, aby uzyskać nową ostatnią cyfrę.

PHP, 60 55 54 46 bajtów

Dzięki @ user59178 za odcięcie kilku bajtów, @AlexHowansky za bajt, @Titus za kolejne kilka bajtów

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

Wywoływany z linii poleceń za pomocą -r. Naiwna metoda, która zapętla się, gdy liczba jest wielokrotnością 3 lub ma 3 cyfry.

PHP, 47 41 bajtów

zainspirowany przez Xanderhall , ale najnowszy pomysł w końcu uzasadnia własną odpowiedź.

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

lub

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

Wykorzystuje to fakt, że dane wejściowe pochodzą również z sekwencji: For $n%3==1, nowy moduł jest 2. Dla $n%3==2nowego modulo jest 4-3=1. $n%3==0nigdy się nie zdarza

Uruchom jako potok z -Rlub wypróbuj je online .

APL (Dyalog Unicode) , 33 28 27 19 bajtów ^SBCS

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

Wypróbuj online!

-6 dzięki Adámowi. -8 dzięki ngn.

Stare objaśnienie:

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 bajtów ^SBCS

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

Wypróbuj online!

Dzięki Adám. -6 dzięki ngn.

Stare objaśnienie:

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 bajtów

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

Wypróbuj online!

Znajduje pierwszą liczbę większą niż wartość wejściowa, która nie ma trójki i ma resztę, gdy jest modulowana przez 3. Miałem nadzieję, że zrobię coś fantazyjnego z warunkiem, !/3/&*%3ale nie działa z !.:(

Wyjaśnienie:

{                      }   # 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 bajtów

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

siatkowy, 30 bajtów

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

Wypróbuj online!

Wyjaśnienie

1: inicjalizacja

in v

Konwertuje input na number, a następnie przechodzi w dół ( v)

2: pętla

?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: końcowy

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

Partia, 93 bajty

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

Pobiera dane wejściowe na STDIN.

CJam, 19 bajtów

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

ONLINE

Wyjaśnienie:

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

Gdyby zapytano mniej szczegółowe wyjaśnienie, zrobiłbym to:

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 bajtów

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

Zestaw testowy

Jestem pewien, że mogę to zagrać w golfa ... to jest to samo, co moja odpowiedź CJam.

Wyjaśnienie:

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 bajty

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

Rekurencyjnie zapętla się, gdy njest podzielna przez 3, lub zawiera 3 w swojej reprezentacji ciągu. Chociaż używam niezoptymalizowanej rekurencji, był w stanie obsłużyć 2999999 jako dane wejściowe, więc powinno być w porządku.

Bez golfa

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