Contagem sem 3

45

fundo

Quando eu estava no ensino fundamental, costumávamos jogar um jogo na aula de matemática que é o seguinte.

Todas as crianças se sentam em um grande círculo e se revezam na contagem, começando em 1 .

No entanto, os seguintes números devem ser ignorados durante a contagem:

  • Números que são múltiplos de 3 .
  • Números que têm um 3 em sua representação decimal.

Os 15 primeiros números que as crianças devem dizer são

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

Sempre que alguém erra um número - diz um número que não está na sequência ou pula um número que está - ele é removido do círculo. Isso continua até restar apenas um garoto.

Tarefa

Você é ruim neste jogo, então decide trapacear. Escreva um programa ou uma função que, dado um número da sequência, calcule o próximo número da sequência.

Você não precisa manipular números que não podem ser representados usando o tipo numérico nativo do seu idioma, desde que seu programa funcione corretamente até a entrada 251 e que seu algoritmo funcione para entradas arbitrariamente grandes.

Entrada e saída podem usar qualquer base conveniente.

Como você precisa ocultar seu código, ele deve ser o mais curto possível. De fato, isso é , então o código mais curto em bytes vence.

Casos de teste

  1 ->   2
  2 ->   4
 11 ->  14
 22 ->  25
 29 ->  40
251 -> 254
Dennis
fonte
5
Eu sinto que nós tivemos um desafio como este ...
Conor O'Brien
5
Sempre 7foi ignorado quando eu o toquei, mas você diria outra coisa, em vez de ir para o próximo número da fila.
mbomb007
12
@ mbomb007: Quando eu joguei, você não seria removido do círculo. Em vez disso, você beberia. Mas isso não estava na escola primária. De qualquer forma, ultrapassar os 80 anos era quase impossível, principalmente após a primeira hora.
precisa
4
@ mbomb007: Isso dependeria da prova do que você estiver bebendo.
precisa

Respostas:

21

Braquilog , 10 bytes

<.='e3:I'*

Experimente online!

Explicação

(?)<.                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
Fatalizar
fonte
3
Respostas como esta são tão bonito em Brachylog :)
Emigna
3
@ Emigna Quase às vezes não parece golfe o suficiente, porque basicamente descreve o desafio diretamente. Esse é o caso para um monte de respostas em que a linguagem :)
Fatalize
14

JavaScript (ES6), 30 bytes

f=n=>++n%3*!/3/.test(n)?n:f(n)
ETHproductions
fonte
O índice 2 e o índice 3 retornam o número 4 com esta função
nl-x
1
@ nl-x Sim, porque 4 é o próximo número na sequência após 2 e 3. Não está indexado; é simplesmente o próximo número na sequência.
ETHproductions
Eu acho que estou começando a entendê-lo ... Meu mal
nl-x
8

J, 24 bytes

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

Abordagem direta que apenas repete a partir da entrada n até encontrar o próximo número válido pelas regras.

Formulários cinco smileys, $:, :), 0=, =|, e >:.

Uso

   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

Explicação

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
milhas
fonte
Bem, J é provavelmente a linguagem de programação mais propensa a smileys.
Adám
8

Python 2, 73 66 43 bytes

Agradeço ao xnor por me dizer que eu estava sendo bobo usando 2 variáveis, e também a Mitch Schwartz.

x=~input()
while'3'[:x%3]in`x`:x-=1
print-x
Daniel
fonte
1
A atualização de duas variáveis ​​parece muito complicada. Eu acho que você só precisa x=input()+1 while'3'[:x%3]in`x`:x+=1 print x.
Xnor
@xnor, oh sim bobo me Eu não sei por que fiz isso
Daniel
Aprimoramento de um byte, começando com x=~input(), subtraindo em vez de adicionar e imprimir -x.
Mitch Schwartz
1
@Artyer Esse é apenas um dos três erros introduzidos nessa edição.
Mitch Schwartz
1
@Dopapp A revisão atual (sem o espaço) é de 43 bytes? mothereff.in/...
Artyer
7

05AB1E , 11 bytes

[>Ð3ås3Ö~_#

Experimente online!

Explicação

               # 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
Emigna
fonte
7

Perl, 19 bytes

Código de 18 bytes + 1 para -p.

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

Uso

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

perl -pe '++$_%3&&!/3/||redo' <<< 11
14
Dom Hastings
fonte
1
@ dan1111 É Perl, o que você esperava? Clareza?
Erik the Outgolfer 4/16
1
@EriktheGolfer what? Esta é a própria definição de "código de auto-documentação".
@ dan1111 Parece que você conhece Perl. Não tenho idéia de como o Perl funciona, por causa de sua famosa estranheza.
Erik the Outgolfer 4/16
@ dan1111 Obrigado! Muito feliz com o quão curto acabou!
Dom Hastings
1
@DomHastings Bem, no PPCG, consideramos o Perl como o nível mais alto de estranheza e Jelly / Actually / O5AB1E como o nível mais alto de confusão. Parece que você ainda não tenha visto este desafio, então :)
Erik o Outgolfer
6

Java 8, 57 56 55 50 bytes

Obrigado a @Numberknot por 1 byte Obrigado a @ Kevin Cruijssen por 5 bytes

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

Isto é um Function<Integer, Integer>

Explicação

Implementação ingênua que simplesmente aumenta até atingir um número aceitável.

Classe de teste

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

}

Saída da classe de teste:

1 2 4 5 7 8 10 11 14 16
Phoenix socrático
fonte
2
Você pode usar em |vez de||
Numberknot 3/16/16
1
@ Numberknot Eu não tinha ideia que os operadores bit a bit funcionavam como lógicos em alguns contextos! Obrigado!
socrático Phoenix
1
Por que o do-while? Apenas um regular para-ciclo é mais curto: i->{for(;++i%3<1|(i+"").contains("3"););return i;}( 50 bytes )
Kevin Cruijssen
@KevinCruijssen Bem ... Pensei em comparar whilee do-while, e ambos me deram a mesma pontuação, mas gostei da do-whileaparência ... Não pensei em usar um forloop ... Obrigado!
socrático Phoenix
5

Japonês, 18 bytes

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

Teste on-line

Finalmente tenho a chance de usar ß:-)

Como funciona

                    // 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
ETHproductions
fonte
5

PowerShell v2 +, 46 bytes

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

Pega entrada $args[0], adiciona 1, salva $a, inicia um forloop. O condicional mantém o loop ativo enquanto qualquer um $a-match3(correspondência de expressão regular) -or $a%3é zero (o !que é 1). O loop simplesmente aumenta $a++. No final do ciclo, simplesmente colocamos $ano pipeline e a saída via implícita Write-Outputacontece na conclusão do programa.

Exemplos

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
AdmBorkBork
fonte
4

R, 46 bytes

n=scan()+1;while(!n%%3|grepl(3,n))n=n+1;cat(n)
plannapus
fonte
Eu acho que é permitido retornar um valor (em vez de imprimir em stdout), para que você possa salvar 5 bytes apenas ao ninvés de cat(n).
Rbdbull #
4

Python 2, 49 44 42 bytes

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

A outra entrada Python supera isso (edit: não mais :-D), mas eu a publiquei porque gosto bastante de sua abordagem recursiva. Agradeço a Mitch Schwarz e Erik, o jogador de golfe, por me ajudarem a diminuir isso.

0WJYxW9FMN
fonte
1
Você pode fazer isso em Python 2: f=lambda x:f(x+1)if x%3>1or'3'in`x+1`else-~x. Se você quiser manter Python 3, você pode golfe a última x+1para -~xe remover o espaço.
Erik the Outgolfer 4/16
@EriktheGolfer Thanks! Vou mudar para Python 2, pois é muito mais curto.
0WJYxW9FMN 04/11
42s: f=lambda x:'3'[:~x%3]in`~x`and f(x+1)or-~xef=lambda x:f(x+1)if'3'[:~x%3]in`~x`else-~x
Mitch Schwartz
3

Lua, 58 bytes

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

Pyke, 13 bytes

Whii3%!3`i`{|

Experimente aqui!

              - i = input
W             - do:
 hi           -  i += 1
   i3%!       -    not (i % 3)
            | -   ^ or V
       3`i`{  -    "3" in str(i)
              - while ^
Azul
fonte
1
No começo eu pensei que isso era dito whileno começo.
Conor O'Brien
Se você olhar para ele, eu posso ver isso #
Blue
3

C #, 56 , 51 bytes.

Isso é surpreendentemente curto para uma resposta em C #!

x=>{while(++x%3<1|(x+"").Contains("3"));return x;};
Morgan Thrapp
fonte
Você pode reduzi-lo a 43 se torná-lo recursivo t=x=>(++x)%3<1|(x+"").Contains("3")?t(x):x; No Visual Studio, basta definir a variável e defini-la como nula Func<int, int> t = null;e, em seguida, definir a função recursiva na linha a seguir.
Grax32
O problema é que, se eu o tornar recursivo, preciso contar as definições de função e tipo.
Morgan Thrapp
Existe algum lugar onde eu possa ir para ver essas diretrizes? Acho C # golfe confuso aqui.
Grax32
@ Grax Basicamente, você precisa incluir qualquer código necessário para que o código seja executado, exceto a atribuição a um nome no caso de uma função não recursiva. Infelizmente, não sei onde você encontrará um conjunto de diretrizes concretas.
Morgan Thrapp
@MorganThrapp confira a minha resposta c # com recursividade em 49 bytes :)
lee
3

Haskell, 50 48 bytes

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

Experimente em Ideone. Economizou 2 bytes graças a @Charlie Harding .

Alternativa: (50 bytes)

g=f.(+1)
f n|mod n 3<1||(elem '3'.show)n=g n|1<3=n
Laikoni
fonte
1
Também 50 bytes: until(\x->mod x 3>0&&notElem '3'(show x))succ.succ.
N
3

Pitão, 11 bytes

f&-I`T3%T3h

Experimente on-line: Demonstration or Test Suite

Explicação:

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
Jakube
fonte
2

GolfSharp , 43 bytes

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

Ruby, 47 bytes

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

Eu realmente sinto que isso pode ser jogado ainda mais.

Elenian
fonte
você pode usar em ivez de"#{i}"
Mhmd 5/16
2

MATL , 14 bytes

`Qtt3\wV51-hA~

Experimente online!

Explicação

`       % 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
Luis Mendo
fonte
2

Labirinto , 117 102 bytes

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

Experimente online!

O labirinto é uma linguagem de programação bidimensional baseada em pilha e, nas junções, a direção é determinada pelo topo da pilha (positivo vai para a direita, negativo vai para a esquerda, zero vai direto). Existem dois loops principais nesses programas. O primeiro modifica a entrada inteira em 3 e incrementa se 0. O segundo verifica repetidamente se o último dígito é 3 (subtraindo 3 e modificando por 10) e depois dividindo por 10 para obter um novo último dígito.

Robert Hickman
fonte
2

PHP, 60 55 54 46 bytes

Graças a @ user59178 por remover alguns bytes, @AlexHowansky por um byte, @Titus por mais alguns bytes

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

Chamado na linha de comando com -r. Método ingênuo que faz um loop enquanto o número é múltiplo de 3 ou tem 3 em seus dígitos.

Xanderhall
fonte
1
Você pode salvar 7 bytes apenas usando um programa que recebe entradas da linha de comando, e não uma função: for($i=$argv[1];!(++$i%3)|strpos(" $i",'3'););echo$i;pode ser possível obter um melhor desempenho atribuindo $iao usá-lo também.
user59178
@ user59178 eu assumi a função teve que retornar $ i
Xanderhall
na maioria das vezes, as perguntas são bastante flexíveis na maneira como a entrada e a saída são feitas, desde que a coisa certa seja dada e recebida. Além disso, procurando respostas em outros idiomas, a maioria escolhe imprimir no stdout.
user59178
Salve um byte comstrpos(_.$i,'3')
Alex Howansky 4/16
Salve um byte com %3<1, um com em 51vez de '3', mais dois com em strstr($i)vez de strpos(_.$i)e outros dois trocando os |operandos na segunda versão: <?for(;strstr($i=++$argv[1],51)|$i%3<1;);echo$i;-> 48 bytes
Titus
2

PHP, 47 41 bytes

inspirado por Xanderhall , mas a idéia mais recente finalmente justifica uma resposta própria.

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

ou

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

Isso tira vantagem do fato de que a entrada também é da sequência: For $n%3==1, o novo módulo é 2. Pois $n%3==2, o novo módulo é 4-3=1. $n%3==0nunca acontece.

Execute como pipe -Rou experimente-os online .

Titus
fonte
2

APL (Dyalog Unicode) , 33 28 27 19 bytes SBCS

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

Experimente online!

-6 graças a Adám. -8 graças a ngn.

Explicação antiga:

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 bytes SBCS

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

Experimente online!

Graças a Adám. -6 graças a ngn.

Explicação antiga:

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
Ven
fonte
2

Perl 6 , 27 25 24 bytes

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

Experimente online!

Encontra o primeiro número maior que a entrada que não possui três e tem um restante quando modulado por 3. Eu esperava fazer algo sofisticado com a condição, como !/3/&*%3mas não funciona com o !.:(

Explicação:

{                      }   # 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
Brincadeira
fonte
1

C, 81 bytes

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;}
Steadybox
fonte
1

reticular, 30 bytes

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

Experimente online!

Explicação

1: inicialização

in v

Isso converte a entrada iem um número ne depois desce ( v)

2: loop

?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
Conor O'Brien
fonte
1

Lote, 93 bytes

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

Recebe entrada em STDIN.

Neil
fonte
1

CJam, 19 bytes

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

CONECTADOS

Explicação:

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

Se uma explicação menos detalhada fosse solicitada, eu teria feito o seguinte:

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
Erik, o Outgolfer
fonte
1

Pitão, 19 bytes

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

Suíte de teste

Tenho certeza de que posso jogar isso ... é o mesmo que minha resposta CJam.

Explicação:

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
Erik, o Outgolfer
fonte
Postei uma solução bem mais curta. No entanto, aqui está uma dica para sua abordagem: não use a variável J. Você pode incrementar Q. E se você estiver fazendo isso de maneira inteligente, poderá inserir a operação na condição while: W|!%=hQ3/Q \ 3; Q`.
Jakube 8/11
Desculpe:W|!%=hQ3/`Q\3;Q
Jakube 8/16
@Jakube A variável não está apenas aumentando, mas obrigado.
Erik the Outgolfer
1

Clojure, 73 bytes

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

Faz um loop recursivamente enquanto né divisível por 3 ou contém um 3 em sua representação de sequência. Embora eu esteja usando recursão não otimizada, ele foi capaz de lidar com 2999999 como uma entrada, portanto deve estar ok.

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