Prima occorrenza nella sequenza di Sixers

17

La sequenza Sixers è un nome che può essere assegnato alla sequenza A087409 . Ho imparato a conoscere questa sequenza in un video di Numberphile e può essere costruita come segue:

Innanzitutto, prendi i multipli di 6, scritti nella base 10:

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

Successivamente, concatena i numeri in un flusso di cifre:

61218243036...

Infine, raggruppa il flusso in coppie e interpreta ciascuno come un numero intero:

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

Mentre raggruppiamo i numeri in coppie, il numero massimo nella sequenza sarà 99 e si scopre che tutti gli interi non negativi inferiori a 100 sono rappresentati nella sequenza. Questa sfida è trovare l'indice della prima istanza di un numero nella sequenza di Sixers.

Ingresso

Un numero intero nell'intervallo [0-99]. Non è necessario tenere conto dei numeri al di fuori di questo intervallo e la soluzione può avere qualsiasi comportamento se viene fornito un tale input.

Produzione

L'indice della prima occorrenza del numero di input nella sequenza di Sixers. Questo può essere 0 o 1 indicizzato; per favore dì quale stai usando nella tua risposta.

Regole

  • La procedura per generare la sequenza annotata nell'introduzione è solo a scopo illustrativo, è possibile utilizzare qualsiasi metodo desiderato purché i risultati siano gli stessi.
  • È possibile inviare programmi o funzioni completi.
  • Sono consentiti tutti i metodi sensibili di input e output.
  • Le scappatoie standard non sono ammesse.
  • Si raccomandano collegamenti per testare il codice online!
  • Questo è code-golf , quindi vince la risposta più breve in ogni lingua!

Casi test

Ecco un elenco di tutti gli input e output, nel formato 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
fonte
6
Può essere utile sapere che considerare 6, 2*6, 3*6,..., 325*6è sufficiente per generare tutti i possibili valori
— Luis Mendo,
@LuisMendo Hai ragione, stavo discutendo se includerlo nella descrizione della sfida. Un commento è un buon posto anche per questo: o)
— Ho
Possiamo prendere l'input-integer come stringa, con quelli imbottita con uno 0 (vale a dire , , , ...)? n<10000102
— Kevin Cruijssen,
10
@KevinCruijssen Hmmm, l'input come stringa va bene, ma il padding sinistro con 0 è un po 'troppo IMO.
— Ha

Risposte:

12

JavaScript (ES6),  71 65  55 byte

L'output è indicizzato 0.

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

Provalo online!

Come?

Usando una funzione ricorsiva, "consumiamo" i primi 2 caratteri della stringa di multipli concatenati di 6 o aggiungiamo nuovi caratteri se ne abbiamo meno di 2.

Esempio per 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

Commentate

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
fonte
12

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

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

Provalo online!

  • -2 byte, grazie a Grimy
  • -3 byte, grazie ad ArBo
  • -6 byte, grazie a xnor
— TFeld
fonte
1
3 byte più brevi come 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 Ancora meglio, f=lambda n,s='612',i=18:n-int(s[:2])and-~f(n,s[2:]+`i`,i+6)(indicizzato 0).
— xnor
8

Perl 6 , 31 byte

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

Provalo online!

Utilizza la sequenza con 1 indice.

Spiegazione:

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

05AB1E , 9 byte

₄L6*J2ôIk

0-indicizzati. Accetta un singolo numero intero o un elenco di numeri interi come input.

Provalo online o verifica tutti i casi di test .

Spiegazione:

₄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
fonte
Il comportamento predefinito è unirsi come stringa o esistono operatori separati per unirsi come stringa e unirsi come numero?
— max
@maxb Nel complesso 05AB1E non necessita di conversioni esplicite. Tutti gli interi possono anche essere usati per funzioni stringa come sostituire o dividere e tutte le stringhe create (che sono numeri interi) possono anche essere usate come numeri. Quindi 100, "100"e 100.0sono gli stessi per la maggior parte delle funzioni come controlli uguali e simili. Ci sono ancora funzioni di cast in int e cast in string in 05AB1E per alcune funzionalità, come l'ordinamento (ordinamento numerico vs lessicografico) o per rimuovere le cifre decimali dopo la virgola da un float quando si esegue il casting in int, ma non vengono utilizzate così spesso .
— Kevin Cruijssen,
@maxb Suggerimento 05AB1E pertinente che fornisce alcuni esempi aggiuntivi.
— Kevin Cruijssen,
4

Carbone , 12 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. 0-indicizzati. Spiegazione:

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

APL (Dyalog Unicode) , 26 byte

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

Provalo online! - Test per tutti gli input validi.

Come:

{⍵⍳⍨⍎¨((≠\=⍨)⊂⊢)∊⍕¨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é
fonte
puoi rimodellare il vettore appiattito come puoi fare in K? Google suggerisce ⍴ma APL mi spaventa ...
— streetster
@streetster sì, ⍴è la rimodulazione di APL. Quindi, se vuoi rimodellare un vettore appiattito, devi solo farlo<new shape vector> ⍴ <vector to reshape>
— J. Sallé,
quindi potresti usare reshape per creare la lista 2xN e poi convertirli tutti in numeri interi?
— streetster,
Potresti, ma non penso che sarebbe più breve della mia attuale risposta. Un problema sarebbe che, per la mia risposta, rimodellare la stringa in una matrice 1117 × 2 e poi convertirla in numeri interi creerebbe un vettore con 1117 numeri interi a una cifra. Vedi la differenza tra il metodo che sto usando e il rimodellamento
— J. Sallé,
Ah, la mia corda appiattita viene rimodellata in qualcosa di più praticabile :)
— Stradina il
3

Python 3 , 87 81 byte:

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

input intero, output indicizzato 0.

Provalo online!

-6 byte, grazie a @TFeld.

— MrGeek
fonte
2

MathGolf , 10 byte

•╒6*y░2/i=

Provalo online!

Sostanzialmente uguale alla risposta 05AB1E, ma perdo un byte dovendo convertire esplicitamente il numero concatenato in stringa.

Spiegazione

•╒             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
fonte
2

K (oK) , 22 byte

Soluzione:

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

Provalo online!

Spiegazione:

0-indicizzati.

(.:'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
fonte
2

Gelatina , 10 byte

ȷ×€6DFs2Ḍi

Provalo online!

Il collegamento TIO fornisce tutti i valori da 0 a 99.

Spiegazione

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

Java 10, 119 104 102 byte

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

Porta della risposta Python 2 di @TFeld .
-2 byte grazie a @Imus .

1-indicizzati.

Provalo online.

Spiegazione:

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

Originale 119 versione 117 byte:

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-indicizzati.

Provalo online.

Spiegazione:

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
fonte
1
Puoi salvare 2 byte usando "" + n / 10 + n% 10 invece di n> 9? N + "": "0" + n
— Imus
1

CJam , 17 byte

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

Provalo online!

0-based.

Spiegazione

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
fonte
Per curiosità, perché CJam ha i builtin per tutti gli interi nell'intervallo [10,20], nonché cinque diversi builtin predefiniti da una stringa vuota "", ma nessun builtin per100 o 1000?
— Kevin Cruijssen,
@KevinCruijssen Non sono sicuro ... Ma avere variabili con valori predefiniti come 0o ""talvolta è utile per i loop, perché questi sono spesso i valori iniziali desiderati. Per quanto riguarda il non avere 100o 1000, sì, sono d'accordo che sarebbero più utili che dire 18o19
— Luis Mendo,
1
È un peccato che gli zero iniziali siano fastidiosi, altrimenti potresti abbandonare il :~e idal tuo codice. :(
— Erik the Outgolfer,
1

Japt , 12 byte

0-indicizzati.

L²õ*6 ¬ò b¥U

Provalo o prova tutti gli ingressi

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)
— ispido
fonte
1

Retina , 83 77 byte

Sono davvero fuori allenamento per la complicata programmazione in Retina, ma sono soddisfatto della lunghezza in cui sono riuscito a farlo.

Emette il risultato indicizzato 0.

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

L`..
m`^0

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

C`¶

Provalo online

Spiegazione

.+                   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
fonte
1

Retina 0.8.2 , 36 byte

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

Provalo online! Il link include la suite di test. 1-indicizzati. Spiegazione:

^
2406$*_

Prefisso 2406 _s all'ingresso.

_{6}
$.`

Sostituisci ogni 6 _s con il numero di _s precedenti . Questo genera la sequenza 0, 6, 12... 2400, ma concatena automaticamente i numeri.

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

Salta lo 0 iniziale e trova la prima coppia di cifre che corrispondono alle ultime due cifre, ovvero l'input con spaziatura zero (poiché la stringa termina 0; in effetti, la suite di test utilizza il fatto che termina 00).

$#1

Stampa il numero di coppie di cifre fino alla partita inclusa.

Retina 1 salva un paio di byte perché il suo operatore di ripetizione stringa è un byte più breve e per impostazione predefinita è già l' _operando di destra, in modo che la seconda riga di codice diventi giusta 2406*. Un'altra caratteristica di Retina 1 è il >modificatore che genera la sostituzione nel contesto del separatore dopo la corrispondenza, che nel caso $.>`causa la lunghezza della corrispondenza nel risultato. Anche se questo costa un byte, lo salviamo immediatamente poiché non è necessario abbinare0 . (Anche le ripetizioni devono essere ridotte di 6.) Retina 1 può anche fare l'aritmetica di base in una sostituzione. Ciò significa che non dobbiamo ricorrere a trucchi per prendere multipli di 6, invece generiamo solo i numeri1..400e moltiplicare per 6 nella sostituzione. Sorprendentemente, anche questo non influisce sul conteggio complessivo dei byte, poiché il risultato finale è simile al seguente:

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

Clojure, 102 byte

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

Così lungo! :(

— NikoNyrh
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.