Première occurrence dans la séquence Sixers

17

La séquence Sixers est un nom qui peut être donné à la séquence A087409 . J'ai appris cette séquence dans une vidéo Numberphile , et elle peut être construite comme suit:

Tout d'abord, prenez les multiples de 6, écrits en base 10:

6, 12, 18, 24, 30, 36, ...

Ensuite, concaténez les nombres en un flux de chiffres:

61218243036...

Enfin, regroupez le flux en paires et interprétez chacune comme un entier:

61, 21, 82, 43, 3, ...

Comme nous regroupons les nombres en paires, le nombre maximum dans la séquence sera 99, et il s'avère que tous les entiers non négatifs inférieurs à 100 sont représentés dans la séquence. Ce défi consiste à trouver l'indice de la première instance d'un nombre dans la séquence de Sixers.

Contribution

Un entier dans la plage [0-99]. Vous n'avez pas besoin de prendre en compte les nombres en dehors de cette plage, et votre solution peut avoir n'importe quel comportement si une telle entrée est donnée.

Production

L'index de la première occurrence du numéro d'entrée dans la séquence Sixers. Cela peut être indexé 0 ou 1; veuillez indiquer ce que vous utilisez dans votre réponse.

Règles

  • La procédure pour générer la séquence notée dans l'introduction est uniquement à des fins d'illustration, vous pouvez utiliser n'importe quelle méthode que vous aimez tant que les résultats sont les mêmes.
  • Vous pouvez soumettre des programmes ou des fonctions complets.
  • Toutes les méthodes d'entrée et de sortie sensées sont autorisées.
  • Les failles standard ne sont pas autorisées.
  • Des liens pour tester votre code en ligne sont recommandés!
  • C'est le golf de code , donc la réponse la plus courte dans chaque langue gagne!

Cas de test

Voici une liste de toutes les entrées et sorties, au format input, 0-indexed output, 1-indexed output.

0   241 242
1   21  22
2   16  17
3   4   5
4   96  97
5   126 127
6   9   10
7   171 172
8   201 202
9   14  15
10  17  18
11  277 278
12  20  21
13  23  24
14  19  20
15  29  30
16  32  33
17  297 298
18  35  36
19  38  39
20  41  42
21  1   2
22  46  47
23  69  70
24  6   7
25  53  54
26  22  23
27  11  12
28  62  63
29  219 220
30  65  66
31  68  69
32  71  72
33  74  75
34  49  50
35  357 358
36  80  81
37  83  84
38  25  26
39  89  90
40  92  93
41  27  28
42  42  43
43  3   4
44  101 102
45  104 105
46  8   9
47  177 178
48  110 111
49  13  14
50  28  29
51  119 120
52  122 123
53  417 418
54  79  80
55  128 129
56  131 132
57  134 135
58  55  56
59  437 438
60  140 141
61  0   1
62  31  32
63  75  76
64  5   6
65  120 121
66  82  83
67  10  11
68  161 162
69  164 165
70  58  59
71  477 478
72  170 171
73  173 174
74  34  35
75  179 180
76  182 183
77  497 498
78  85  86
79  188 189
80  191 192
81  18  19
82  2   3
83  78  79
84  93  94
85  7   8
86  37  38
87  168 169
88  12  13
89  228 229
90  88  89
91  218 219
92  221 222
93  224 225
94  64  65
95  557 558
96  230 231
97  233 234
98  40  41
99  239 240
code-golf  sequence 
— Sok
source
6
Il peut être utile de savoir que la prise en compte 6, 2*6, 3*6,..., 325*6est suffisante pour générer toutes les valeurs possibles
— Luis Mendo
@LuisMendo Vous avez raison, je me demandais s'il fallait l'inclure dans la description du défi. Un commentaire est aussi un bon endroit pour cela: o)
— Sok
Peut - on prendre l'entrée entier sous forme de chaîne, avec les rembourré avec un 0 (c. -à , , , ...)? n<10000102
— Kevin Cruijssen
10
@KevinCruijssen Hmmm, l'entrée en tant que chaîne est très bien, mais le remplissage gauche avec 0 est un peu trop loin IMO.
— Sok

Réponses:

12

JavaScript (ES6),  71 65  55 octets

La sortie est indexée 0.

n=>(g=([a,b,...c])=>b?a+b-n&&1+g(c):g([a]+6*++i))(i='')

Essayez-le en ligne!

Comment?

En utilisant une fonction récursive, nous «consommons» les 2 premiers caractères de la chaîne de multiples concaténés de 6 , ou ajoutons de nouveaux caractères si nous en avons moins de 2.

Exemple pour n=3 :

 string | operation                          | result
--------+------------------------------------+--------
 ''     | not enough characters: append '6'  |   0
 '6'    | not enough characters: append '12' |   0
 '612'  | consume '61', increment the result |   1
 '2'    | not enough characters: append '18' |   1
 '218'  | consume '21', increment the result |   2
 '8'    | not enough characters: append '24' |   2
 '824'  | consume '82', increment the result |   3
 '4'    | not enough characters: append '30' |   3
 '430'  | consume '43', increment the result |   4
 '0'    | not enough characters: append '36' |   4
 '036'  | consume '03': success              |   4

Commenté

n => (             // n = input
  g = (            // g is a recursive function taking either a string or an array of
                   // characters split into:
    [a, b,         //   a = 1st character, b = 2nd character,
           ...c]   //   c[] = array of all remaining characters
  ) =>             //
    b ?            // if b is defined:
      a + b - n && //   if n subtracted from the concatenation of a and b is not zero:
        1 + g(c)   //     add 1 to the final result and do a recursive call with c[]
                   //   (otherwise: yield 0 and stop recursion)
    :              // else:
      g(           //   do a recursive call with:
        [a] +      //     the concatenation of a (forced to an empty string if undefined)
        6 * ++i    //     and 6 * i, with i pre-incremented
      )            //   end of recursive call
)(i = '')          // initial call to g with an empty string,
                   // and i set to empty string as well (zero'ish)
— Arnauld
source
12

Python 2 , 93 92 85 83 81 68 65 59 octets

f=lambda n,s='612',i=18:n-int(s[:2])and-~f(n,s[2:]+`i`,i+6)

Essayez-le en ligne!

  • -2 octets, grâce à Grimy
  • -3 octets, grâce à ArBo
  • -6 octets, grâce à xnor
— TFeld
source
1
3 octets plus court qu'un lambda:f=lambda n,s='612',i=3:n-int(s[:2])and f(n,s[2:]+`i*6`,i+1)or i-2
— ArBo
@ArBo Encore mieux, f=lambda n,s='612',i=18:n-int(s[:2])and-~f(n,s[2:]+`i`,i+6)(indexé 0).
— xnor
8

Perl 6 , 31 octets

{+(comb(2,[~] 1..ⅮX*6)...$_)}

Essayez-le en ligne!

Utilise la séquence indexée 1.

Explication:

{                            } # Anonymous code block
              1..Ⅾ             # The range 1 to 500
                   X*6         # All multiplied by 6
          [~]                  # Join as one giant string
   comb(2,            )        # Split into pairs of characters
                       ...$_   # Take up to the input
 +(                         )  # And return the length of the list
— Jo King
source
5

05AB1E , 9 octets

₄L6*J2ôIk

0 indexé. Accepte soit un seul entier, soit une liste d'entiers en entrée.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

₄L         # Create a list in the range [1,1000]
  6*       # Multiply each value by 6
    J      # Join the entire list of integers together to a string
     2ô    # Split into parts of size 2
       Ik  # Get the index of the input integer(s)
           # (and output the result implicitly)
— Kevin Cruijssen
source
Le comportement par défaut est-il de se joindre en tant que chaîne ou existe-t-il des opérateurs distincts pour se joindre en tant que chaîne et se joindre en tant que nombre?
— max
@maxb Global 05AB1E n'a besoin d'aucune conversion explicite. Tous les entiers peuvent également être utilisés pour des fonctions de chaîne comme remplacer ou fractionner, et toutes les chaînes créées (qui sont des entiers) peuvent également être utilisées comme des nombres. Alors 100, "100"et 100.0sont les mêmes pour la plupart des fonctions telles que les contrôles et les mêmes tels. Il existe toujours des fonctions de conversion en int et de conversion en chaîne dans 05AB1E pour certaines fonctionnalités, comme le tri (tri numérique vs tri lexicographique), ou pour supprimer les chiffres décimaux après la virgule d'un flottant lors de la conversion en int, mais ils ne sont pas souvent utilisés .
— Kevin Cruijssen
@maxb Conseil pertinent 05AB1E donnant quelques exemples supplémentaires.
— Kevin Cruijssen
4

Fusain , 12 octets

Ｉ⌕Ｉ⪪⭆φ×⁶⊕ι²Ｎ

Essayez-le en ligne! Le lien est vers la version détaillée du code. 0 indexé. Explication:

     φ           Predefined constant 1000
    ⭆           Map over implicit range and join
        ι       Current index
       ⊕        Incremented
     ×⁶         Multiplied by 6
   ⪪      ²     Split into pairs of digits
  Ｉ             Cast to integer
           Ｎ    Input as a number
 ⌕              Find its index
Ｉ               Cast to string
                Implicitly print
— Neil
source
4

APL (Dyalog Unicode) , 26 octets

{⍵⍳⍨⍎¨((≠\=⍨)⊂⊢)∊⍕¨6×⍳325}

Essayez-le en ligne! - Tests pour toutes les entrées valides.

Comment:

{⍵⍳⍨⍎¨((≠\=⍨)⊂⊢)∊⍕¨6×⍳325} ⍝ Dfn, input is ⍵.
                    6×⍳325  ⍝ Generates the first 325 multiples of 6.
                  ⍕¨        ⍝ Format each number into a string
                 ∊          ⍝ Enlist, flattens the vector
       (      ⊂⊢)           ⍝ Dyadic enclose, takes a boolean mask as left argument
        (≠\=⍨)              ⍝ Generates the mask 1 0 1 0...
                            ⍝ Enclose then returns the Sixers sequence as a string
     ⍎¨                     ⍝ Execute each element in the string, turning it into a numeric vector
 ⍵⍳⍨                        ⍝ Find the first occurrence of ⍵ in the vector
— J. Sallé
source
pouvez-vous remodeler le vecteur aplati comme vous le pouvez en K? Google suggère ⍴mais APL me fait peur ...
— streetster
@streetster oui, ⍴c'est la refonte d' APL. Donc, si vous voulez remodeler un vecteur aplati, il vous suffit de le faire<new shape vector> ⍴ <vector to reshape>
— J. Sallé
alors pourriez-vous utiliser remodeler pour créer la liste 2xN puis convertir chacun en entier?
— streetster
Vous pourriez, mais je ne pense pas que ce serait plus court que ma réponse actuelle. Un problème serait que, pour ma réponse, le remodelage de la chaîne en une matrice 1117 × 2 puis la conversion en entiers créerait un vecteur avec 1117, des nombres à un chiffre. Voir la différence entre la méthode que j'utilise et le remodelage
— J. Sallé
Ah, ma chaîne aplatie se remodèle en quelque chose de plus réalisable :)
— streetster
3

Python 3 , 87 81 octets:

lambda n:[*zip(*[iter(''.join(map(str,range(6,1951,6))))]*2)].index((*'%02d'%n,))

entrée entière, sortie indexée 0.

Essayez-le en ligne!

-6 octets, grâce à @TFeld.

— MrGeek
source
2

MathGolf , 10 octets

•╒6*y░2/i=

Essayez-le en ligne!

Fondamentalement, la même chose que la réponse 05AB1E, mais je perds un octet en ayant à convertir le nombre concaténé en chaîne explicitement.

Explication

•╒             push [1, 2, ..., 512]
  6*           multiply by 6
    y          join array without separator to string or number
     ░         convert to string (implicit map)
      2/       split into groups of 2 characters
        i      convert to integer (implicit map)
         =     find index of implicit input in the array
— maxb
source
2

K (oK) , 22 octets

Solution:

(.:'0N 2#,/$6*1+!999)?

Essayez-le en ligne!

Explication:

0 indexé.

(.:'0N 2#,/$6*1+!999)? / the solution
                     ? / lookup right in left
(                   )  / do this together
                !999   / range 0..999
              1+       / add 1, range 1...1000
            6*         / multiply by 6, 6...6000
           $           / convert to strings
         ,/            / flatten
    0N 2#              / reshape into 2xN
 .:'                   / value each, convert to numbers
— streetster
source
2

Gelée , 10 octets

ȷ×€6DFs2Ḍi

Essayez-le en ligne!

Le lien TIO donne toutes les valeurs de 0 à 99.

Explication

ȷ          | 1000
 ×€6       | each times 6 (using implicit range from 1..1000)
    D      | Convert to decimal digits
     F     | Flatten
      s2   | Split into pairs
        Ḍ  | Convert back from decimal digits to integer
         i | Find index of left argument to link
— Nick Kennedy
source
2

Java 10, 119 104 102 octets

n->{int i=2;for(var s="612";!s.substring(0,2).equals(""+n/10+n%10);)s=s.substring(2)+6*++i;return~-i;}

Port de la réponse Python 2 de @TFeld .
-2 octets grâce à @Imus .

1 indexé.

Essayez-le en ligne.

Explication:

n->{                            // Method with integer as both parameter and return-type
  int i=2;                      //  Index-integer, starting at 2
  for(var s="612";              //  String, starting at "612"
      !s.substring(0,2)         //  Loop as long as the first two characters of the String
       .equals(                 //  Are not equal to:
               ""+n/10          //   The input integer-divided by 10 as String
               +n%10);)         //   Concatenated with the input modulo-10
                                //   (which will add leading 0s for inputs < 10)
    s=s.substring(2)            //   Remove the first two characters of the String
      +6*++i;                   //   And append 6 times `i`,
                                //   after we've first increased `i` by 1 with `++i`
return~-i;}                     //  Return `i-1` as result

Version originale de 119 117 octets:

n->{var s="";for(int i=0;i<2e3;)s+=i+=6;return java.util.Arrays.asList(s.split("(?<=\\G..)")).indexOf(""+n/10+n%10);}

0 indexé.

Essayez-le en ligne.

Explication:

n->{                            // Method with integer as both parameter and return-type
  var s="";                     //  String we're building, starting empty
  for(int i=0;i<2e3;)           //  Loop `i` in the range [0, 2000):
      s+=i+=6;                  //   Increase `i` by 6 first every iteration
                                //   And then append the updated `i` to String `s`
  return java.util.Arrays.asList(
          s.split("(?<=\\G..)") //  Split the String in parts of size 2 (as array)
         )                      //  Convert the array to a List
          .indexOf(             //  And get the index of the following in this list:
                   ""+n/10      //   The input integer-divided by 10 as String
                   +n%10);}     //   Concatenated with the input modulo-10
— Kevin Cruijssen
source
1
Vous pouvez économiser 2 octets en utilisant "" + n / 10 + n% 10 au lieu de n> 9? N + "": "0" + n
— Imus
1

CJam , 17 octets

325,:)6f*s2/:~ri#

Essayez-le en ligne!

Basé sur 0.

Explication

325,   e# Range [0 1 2 ... 324]
:)     e# Add 1 to each: gives [1 2 3 ... 325]
6f*    e# Multiply each by 6: gives [6 12 18 ... 1950]
s      e# Convert to string: gives "61218...1950"
2/     e# Split into chunks of size 2: gives ["61" "21" ... "95" "0"]
       e# Note how the last chunk has size 1; but it is not used
:~     e# Evaluate each string in that array: gives [61 21 ... 95 0]
ri     e# Read input as an integer
#      e# Index of fist occurrence, 0-based
— Luis Mendo
source
Par curiosité, pourquoi CJam a-t-il intégré tous les entiers de la gamme [dix,20], ainsi que cinq éléments internes différents qui sont tous définis par défaut sur une chaîne vide "", mais aucun élément intégré pour100 ou 1000?
— Kevin Cruijssen
@KevinCruijssen Pas sûr ... Mais avoir des variables avec des valeurs prédéfinies comme 0ou ""est parfois utile pour les boucles, car ce sont souvent les valeurs de départ souhaitées. Quant à ne pas avoir 100ou 1000, oui, je conviens qu'ils seraient plus utiles que de dire 18ou19
— Luis Mendo
1
C'est dommage que les zéros en tête soient ennuyeux, sinon vous pourriez abandonner le :~et ide votre code. :(
— Erik the Outgolfer
1

Japt , 12 octets

0 indexé.

L²õ*6 ¬ò b¥U

Essayez-le ou testez toutes les entrées

L²õ*6 ¬ò b¥U     :Implicit input of integer U
L                :100
 ²               :Squared
  õ              :Range [1,L²]
   *6            :Multiply each by 6
      ¬          :Join to a string
       ò         :Split to array of strings each of length 2
         b       :First 0-based index of
          ¥U     :Test for equality with U (bU wouldn't work here as each string would first need to be cast to an integer, costing more bytes)
— Hirsute
source
1

Rétine , 83 77 octets

Je ne suis vraiment pas habitué à une programmation compliquée dans Retina, mais je suis satisfait de la durée dans laquelle j'ai réussi à le faire.

Génère le résultat indexé 0.

.+
6*1
325+-1%`1+
$0¶6*1$0
1+
$.0
¶

L`..
m`^0

$
¶$+
s`\b(\d+)\b.*\b\1$

C`¶

Essayez-le en ligne

Explication

.+                   Replace the input with 6 in unary
6*1
325+-1%`1+           Do 325 times: append line with previous + 6
$0¶6*1$0
1+                   Convert all lines to decimal
$.0
¶                    Remove line breaks

L`..                 List pairs of digits
m`^0                 Remove leading zeros

$                    Append the original input N on a new line
¶$+
s`\b(\d+)\b.*\b\1$   Remove occurrences of N and anything in between

C`¶                  Count the number of line breaks
— mbomb007
source
1

Retina 0.8.2 , 36 octets

^
2406$*_
_{6}
$.`
^0(..)+?.*\1$
$#1

Essayez-le en ligne! Le lien inclut une suite de tests. 1 indexé. Explication:

^
2406$*_

Préfixez 2406 _s à l'entrée.

_{6}
$.`

Remplacez toutes les 6 _s par le nombre de _s précédents . Cela génère la séquence 0, 6, 12... 2400, mais concaténer automatiquement les numéros.

^0(..)+?.*\1$

Ignorez le 0 de tête et trouvez la première paire de chiffres qui correspond aux deux derniers chiffres, c'est-à-dire l'entrée à remplissage nul (car la chaîne se termine 0; en fait, la suite de tests utilise le fait qu'elle se termine 00).

$#1

Affiche le nombre de paires de chiffres jusqu'à et y compris la correspondance.

Retina 1 enregistre quelques octets car son opérateur de répétition de chaîne est un octet plus court et est déjà par défaut _son opérande de droite, de sorte que la deuxième ligne de code devient juste 2406*. Une autre caractéristique de Retina 1 est le >modificateur qui génère la substitution dans le contexte du séparateur après le match, qui dans le cas de$.>` oblige à inclure la longueur de la correspondance dans le résultat. Bien que cela coûte un octet, nous l'enregistrons immédiatement car nous n'avons plus besoin de faire correspondre le 0tout. (Les répétitions doivent également être réduites de 6.) La rétine 1 peut également effectuer l'arithmétique de base dans une substitution. Cela signifie que nous n'avons pas à recourir à des astuces pour prendre des multiples de 6, au lieu de cela, nous générons simplement les nombres1..400et multipliez par 6 dans la substitution. Remarquablement, cela n'affecte pas non plus le nombre d'octets global, car le résultat final ressemble à ceci:

^
400*
_
$.(6*$>`
^(..)+?.*\1$
$#1
— Neil
source
1

Clojure, 102 octets

#(count(for[i(partition 2(for[i(range 1 326)c(str(* i 6))]c)):while(not=(seq(str(if(< % 10)0)%))i)]i))

Si longtemps! :(

— NikoNyrh
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.