Compter sans 3

45

Contexte

Quand j'étais à l'école primaire, nous jouions à un jeu en classe de mathématiques qui se déroulait comme suit.

Tous les enfants sont assis dans un grand cercle et comptent à tour de rôle, à partir de 1 .

Toutefois, les nombres suivants doivent être ignorés lors du comptage:

  • Les nombres qui sont des multiples de 3 .
  • Nombres qui ont un 3 dans sa représentation décimale.

Les 15 premiers chiffres que les enfants devraient dire sont

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

Chaque fois que quelqu'un se trompe dans un numéro - dit un nombre qui n'est pas dans la séquence ou saute un nombre qui est - il est retiré du cercle. Cela continue jusqu'à ce qu'il ne reste qu'un seul enfant.

Tâche

Vous êtes mauvais à ce jeu, alors vous décidez de tricher. Ecrivez un programme ou une fonction qui, à partir d'un numéro de séquence, calcule le numéro suivant de la séquence.

Vous n'avez pas à gérer des nombres qui ne peuvent pas être représentés à l'aide du type numérique natif de votre langue, à condition que votre programme fonctionne correctement jusqu'à l'entrée 251 et que votre algorithme fonctionne pour des entrées arbitrairement grandes.

L'entrée et la sortie peuvent utiliser n'importe quelle base pratique.

Puisque vous devez cacher votre code, il doit être aussi court que possible. En fait, c'est du , donc le code le plus court en octets l'emporte.

Cas de test

  1 ->   2
  2 ->   4
 11 ->  14
 22 ->  25
 29 ->  40
251 -> 254
Dennis
la source
5
J'ai l'impression que nous avons eu un défi comme celui-ci ...
Conor O'Brien
5
C'était toujours ce 7qui était omis quand je le jouais, mais vous diriez autre chose, au lieu de passer au numéro suivant.
mbomb007
12
@ mbomb007: Quand je l'ai joué, vous ne seriez pas retiré du cercle. Au lieu de cela, vous boiriez. Mais ce n'était pas à l'école primaire. Quoi qu'il en soit, il était presque impossible de dépasser 80 ans, surtout après la première heure.
Tomasz
4
@ mbomb007: Cela dépend de la preuve de ce que vous buvez.
Tomasz

Réponses:

21

Brachylog , 10 octets

<.='e3:I'*

Essayez-le en ligne!

Explication

(?)<.                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
Fataliser
la source
3
Des réponses comme celle-ci sont si belles chez Brachylog :)
Emigna
3
@ Emigna On ne se sent presque jamais assez golfy parce que cela décrit le défi directement. C'est le cas pour beaucoup de réponses dans cette langue :)
Fatalize
14

JavaScript (ES6), 30 octets

f=n=>++n%3*!/3/.test(n)?n:f(n)
ETHproductions
la source
Les index 2 et 3 renvoient le nombre 4 avec cette fonction
nl-x
1
@ nl-x Oui, car 4 est le nombre suivant dans la séquence après 2 et 3. Il n'est pas indexé; c'est simplement le numéro suivant dans la séquence.
ETHproductions
Je pense que je commence à comprendre ... Mon mauvais
nl-x
8

J, 24 octets

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

Approche directe qui consiste simplement à effectuer une itération ultérieure de l'entrée n jusqu'à ce qu'elle trouve le prochain nombre valide par les règles.

Formulaires cinq smileys, $:, :), 0=, =|et >:.

Usage

   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

Explication

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
milles
la source
Eh bien, J est probablement le langage de programmation le plus sujet aux smileys.
Adám
8

Python 2, 73 66 43 octets

Merci à xnor de m'avoir dit que j'étais ridicule en utilisant 2 variables, et également à Mitch Schwartz.

x=~input()
while'3'[:x%3]in`x`:x-=1
print-x
Daniel
la source
1
La mise à jour à deux variables semble beaucoup trop compliquée. Je pense que vous avez juste besoin x=input()+1 while'3'[:x%3]in`x`:x+=1 print x.
xnor
@xnor, oh ouais, moi je suis idiot, je ne sais pas pourquoi j'ai fait ça
Daniel
Amélioration d’un octet en commençant par x=~input(), en soustrayant au lieu d’ajouter et en imprimant -x.
Mitch Schwartz
1
@Artyer C'est seulement 1 des 3 erreurs introduites dans cette édition.
Mitch Schwartz
1
@Dopapp La révision actuelle (sans espace) est de 43 octets? mothereff.in/…
Artyer
7

05AB1E , 11 octets

[>Ð3ås3Ö~_#

Essayez-le en ligne!

Explication

               # 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
la source
7

Perl, 19 octets

Code de 18 octets + 1 pour -p.

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

Usage

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

perl -pe '++$_%3&&!/3/||redo' <<< 11
14
Dom Hastings
la source
1
@ dan1111 C'est Perl, à quoi vous attendiez-vous? Clarté?
Erik the Outgolfer
1
@EriktheGolfer quoi? Telle est la définition même de "code auto-documentant".
@ dan1111 Il semble que vous connaissiez Perl. Je ne sais pas du tout comment Perl fonctionne, à cause de sa fameuse étrangeté.
Erik the Outgolfer
@ dan1111 Merci! Très content de la brièveté du résultat!
Dom Hastings
1
@DomHastings Eh bien, dans PPCG, nous prenons Perl comme niveau supérieur d'étrangeté et Jelly / En fait / O5AB1E comme niveau supérieur de désordre. Il semble que vous n'ayez jamais vu ce défi alors :)
Erik the Outgolfer Le
6

Java 8, 57 56 55 50 octets

Merci à @Numberknot pour 1 octet Merci à @Kevin Cruijssen pour 5 octets

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

C'est un Function<Integer, Integer>

Explication

Une implémentation naïve qui incrémente simplement jusqu'à atteindre un nombre acceptable.

Classe d'essai

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

}

Sortie de la classe de test:

1 2 4 5 7 8 10 11 14 16
Phénix Socratique
la source
2
Vous pouvez utiliser à la |place de||
Numberknot
1
@Numberknot Je ne savais pas que les opérateurs au niveau des bits fonctionnaient de manière logique dans certains contextes! Merci!
Phoenix socratique
1
Pourquoi do-while? Seulement une boucle régulière régulière est plus courte: i->{for(;++i%3<1|(i+"").contains("3"););return i;}( 50 octets )
Kevin Cruijssen
@KevinCruijssen Eh bien ... j'ai pensé comparer whileet do-while, et ils m'ont tous les deux donné le même score, mais j'ai aimé le do-whilelook que j'avais ... je n'ai pas pensé à utiliser une forboucle ... Merci!
Phoenix socratique
5

Japt, 18 octets

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

Testez-le en ligne

J'ai enfin une chance d'utiliser ß:-)

Comment ça marche

                    // 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
la source
5

PowerShell v2 +, 46 octets

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

Prend les entrées $args[0], ajoute 1, enregistre dans $a, démarre une forboucle. La conditionnelle maintient la boucle en cours tant que l'une $a-match3(expression régulière) -or $a%3est égale à zéro (la valeur !est la suivante 1). La boucle s'incrémente simplement $a++. À la fin de la boucle, nous plaçons simplement $ale pipeline et la sortie via implicite Write-Outputse produit à la fin du programme.

Exemples

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
la source
4

R, 46 octets

n=scan()+1;while(!n%%3|grepl(3,n))n=n+1;cat(n)
planificateur
la source
Je pense que le retour d'une valeur (plutôt que l'impression sur stdout) est autorisé, vous pouvez donc économiser 5 octets en ayant juste à la nplace de cat(n).
rturnbull
4

Python 2, 49 44 42 octets

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

L'autre entrée de Python bat ceci (édition: pas plus :-D), mais je l'ai postée parce que j'aime plutôt son approche récursive. Merci à Mitch Schwarz et à Erik the Golfer de m'avoir aidé à raccourcir cette étape.

0WJYxW9FMN
la source
1
Vous pouvez le faire en Python 2: f=lambda x:f(x+1)if x%3>1or'3'in`x+1`else-~x. Si vous voulez garder Python 3, vous pouvez jouer au golf le dernier x+1à -~xet supprimer l'espace.
Erik the Outgolfer
@EriktheGolfer Merci! Je vais le changer en Python 2, car c'est beaucoup plus court.
0WJYxW9FMN
42s: f=lambda x:'3'[:~x%3]in`~x`and f(x+1)or-~xetf=lambda x:f(x+1)if'3'[:~x%3]in`~x`else-~x
Mitch Schwartz
3

Lua, 58 octets

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

Pyke, 13 octets

Whii3%!3`i`{|

Essayez-le ici!

              - i = input
W             - do:
 hi           -  i += 1
   i3%!       -    not (i % 3)
            | -   ^ or V
       3`i`{  -    "3" in str(i)
              - while ^
Bleu
la source
1
Au début, je pensais que cela était dit whileau début.
Conor O'Brien
Si vous y jetez un coup d'œil, je peux voir que
Bleu
3

C #, 56 , 51 octets.

Ceci est étonnamment court pour une réponse en C #!

x=>{while(++x%3<1|(x+"").Contains("3"));return x;};
Morgan Thrapp
la source
Vous pouvez le réduire à 43 si vous le rendez récursif. t=x=>(++x)%3<1|(x+"").Contains("3")?t(x):x; Dans Visual Studio, il vous suffit de définir la variable et de la définir sur null Func<int, int> t = null;, puis de définir la fonction récursive sur la ligne suivante.
Grax32
Le problème est que si je le récursive, je dois alors compter les définitions de fonction et de type.
Morgan Thrapp
Y a-t-il un endroit où je peux aller voir ces directives? Je trouve que le golf en C # est déroutant ici.
Grax32
@Grax En principe, vous devez inclure tout code requis pour son exécution, à l'exception de l'attribution d'un nom dans le cas d'une fonction non récursive. Malheureusement, je ne sais pas où vous trouverez un ensemble de directives concrètes.
Morgan Thrapp
@ MorganThrapp s'il vous plaît vérifier ma réponse c # avec récursion à 49 octets :)
lee
3

Haskell, 50 48 octets

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

Essayez-le sur Ideone. Sauvegardé 2 octets grâce à @Charlie Harding .

Alternative: (50 octets)

g=f.(+1)
f n|mod n 3<1||(elem '3'.show)n=g n|1<3=n
Laikoni
la source
1
Aussi 50 octets: until(\x->mod x 3>0&&notElem '3'(show x))succ.succ.
nimi
3

Pyth, 11 octets

f&-I`T3%T3h

Essayez-le en ligne: démonstration ou suite de tests

Explication:

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
la source
2

GolfSharp , 43 octets

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

Ruby, 47 octets

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

Je sens vraiment que cela peut être joué au golf plus loin.

Elenian
la source
vous pouvez utiliser iau lieu de"#{i}"
Mhmd
2

MATL , 14 octets

`Qtt3\wV51-hA~

Essayez-le en ligne!

Explication

`       % 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
la source
2

Labyrinth , 117 102 octets

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

Essayez-le en ligne!

Labyrinth est un langage de programmation bidimensionnel basé sur des piles et, aux jonctions, la direction est déterminée par le haut de la pile (le positif va à droite, le négatif à gauche, le zéro va tout droit). Il existe deux boucles principales dans ce programme. Le premier modifie l'entrée entière de 3 et s'incrémente à 0. Le second vérifie si le dernier chiffre est 3 (en soustrayant 3 et en modifiant par 10), puis en divisant par 10 pour obtenir un nouveau dernier chiffre.

Robert Hickman
la source
2

PHP, 60 55 54 46 octets

Merci à @ user59178 d’avoir coupé quelques octets, à @AlexHowansky pour un octet, à @Titus pour quelques autres

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

Appelé en ligne de commande avec -r. Méthode naïve qui boucle lorsque le nombre est un multiple de 3 ou en a 3 dans ses chiffres.

Xanderhall
la source
1
Vous pouvez économiser 7 octets en utilisant simplement un programme qui prend une entrée depuis la ligne de commande plutôt qu’une fonction: for($i=$argv[1];!(++$i%3)|strpos(" $i",'3'););echo$i;il est peut-être possible de faire mieux en assignant $itout en l’utilisant.
user59178
@ user59178 J'ai supposé que la fonction devait renvoyer $ i
Xanderhall
la plupart du temps, les questions sont assez flexibles quant à la manière dont l'entrée et la sortie sont effectuées, à condition que la bonne chose soit donnée et reçue. De plus, en regardant les réponses dans d’autres langues, la plupart choisissent d’imprimer sur la sortie standard.
user59178
Enregistrer un octet avecstrpos(_.$i,'3')
Alex Howansky
Enregistrer un octet avec %3<1, l' un avec au 51lieu de '3', deux autres avec au strstr($i)lieu de strpos(_.$i)et deux autres en échangeant les |opérandes dans la deuxième version: <?for(;strstr($i=++$argv[1],51)|$i%3<1;);echo$i;-> 48 octets
Titus
2

PHP, 47 41 octets

inspiré par Xanderhall , mais la dernière idée justifie enfin sa propre réponse.

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

ou

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

Cela tire parti du fait que l'entrée provient également de la séquence: Pour $n%3==1, le nouveau modulo l'est 2. Car $n%3==2le nouveau modulo est 4-3=1. $n%3==0n'arrive jamais.

Exécuter en pipe -Rou essayer en ligne .

Titus
la source
2

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

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

Essayez-le en ligne!

-6 grâce à Adám. -8 grâce à ngn.

Ancienne Explication:

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 SBCS de 17 octets

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

Essayez-le en ligne!

Merci à Adam. -6 grâce à ngn.

Ancienne Explication:

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
la source
2

Perl 6 , 27 25 24 octets

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

Essayez-le en ligne!

Trouve le premier nombre plus grand que l’entrée qui n’a pas de trois et a un reste quand moduloé par 3. J'espérais faire quelque chose de fantaisie avec la condition, comme !/3/&*%3mais ça ne marche pas avec le !.:(

Explication:

{                      }   # 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
Jo King
la source
1

C, 81 octets

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
la source
1

réticulaire, 30 octets

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

Essayez-le en ligne!

Explication

1: initialisation

in v

Ceci convertit le isignal en umber n, puis diminue ( v)

2: boucle

?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: finale

;\$o
 \$o  drop and output
;     terminate
Conor O'Brien
la source
1

Lot, 93 octets

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

Prend une entrée sur STDIN.

Neil
la source
1

CJam, 19 octets

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

En ligne

Explication:

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

Si une explication moins verbeuse était demandée, j'aurais fait ceci:

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 l'Outgolfeur
la source
1

Pyth, 19 octets

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

Suite de tests

Je suis sûr que je peux jouer au golf ... c'est la même chose que ma réponse à CJam.

Explication:

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 l'Outgolfeur
la source
J'ai posté une solution plus courte. Néanmoins, voici un conseil pour votre approche: n'utilisez pas la variable J. Vous pouvez incrémenter Q. Et si vous le faites intelligemment, vous pouvez intégrer l’opération à la condition while: W|!%=hQ3/Q \ 3; Q`.
Jakube
Désolé:W|!%=hQ3/`Q\3;Q
Jakube
@Jakube La variable n'est pas simplement incrémentée, mais merci.
Erik l'Outgolfer
1

Clojure, 73 octets

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

Boucle récursive while nest divisible par 3 ou contient un 3 dans sa représentation sous forme de chaîne. Bien que j'utilise une récursion non optimisée, il a été capable de gérer 2999999 en tant qu'entrée, donc ça devrait aller.

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)))
Carcigenicate
la source