introduzione

Nella base 10, la costante di Champernowne è definita concatenando rappresentazioni di numeri interi successivi. In base 10: 0.1234567891011121314151617...e così via.

Puoi vedere che la prima apparizione di 15inizia con il 20thdecimale:

  Position
  0000000001111111111222222222233333333334444444444555555555566666666
  1234567890123456789012345678901234567890123456789012345678901234567
                     ^
0.1234567891011121314151617181920212223242526272829303132333435363738...
                     ^^
                     15 = position 20

La prima apparizione di 45inizia al 4thdecimale:

  Position
  0000000001111111111222222222233333333334444444444555555555566666666
  1234567890123456789012345678901234567890123456789012345678901234567
     ^               
0.1234567891011121314151617181920212223242526272829303132333435363738...
     ^^
     45 = position 4

Quindi, il compito è facile. Dato un numero intero non negativo, emette la posizione del numero intero nella costante di Champernowne.

Regole

• È possibile fornire una funzione o un programma
• Questo è code-golf , quindi vince l'invio con il minor numero di byte!

Casi test

Input: 20
Output: 30

Input: 333
Output: 56

Input: 0
Output: 11 (note that the 0 before the decimal point is ignored)

Input: 2930
Output: 48

Pyth, 10

hxjkS+QT`Q

Concatena i primi input + 10numeri quindi trova l'indice in base a 0 più uno .. I dieci in più sono necessari solo per 0.

Test Suite

LabVIEW, 29 LabVIEW Primitives

Questo utilizza stringhe per ora. Corrisponde all'input come modello e genera l'offset - (lunghezza input -1).

Javascript, 57 byte

a=prompt();for(y=b=" ";y<a+11;)b+=++y;alert(b.indexOf(a))

Salvato 1 byte grazie a Conor O'Brien.

Haskell, 62 byte

a#b|and$zipWith(==)a b=1|1<2=1+a#tail b 
(#(show=<<[1..])).show

Esempio di utilizzo: (#(show=<<[1..])).show $ 2930-> 48.

Come funziona: a # btrova la posizione di ainside b: se aè il prefisso di britorno 1, altrimenti aggiungi 1a una chiamata ricorsiva con a # tail b. La funzione pointfree (#(show=<<[1..])).showprevede un argomento (senza nome) ne chiama show n # show=<<[1..].

La funzione subIndexfarebbe anche il lavoro di #, ma il necessario import Data.List.Utilsnon paga.

Ruby, 28 anni

->n{[*0..n+10]*''=~/\B#{n}/}

Include uno 0 all'inizio in modo che le corrispondenze siano 1 indicizzate, ma utilizza \Bper richiedere che la corrispondenza non sia all'inizio della stringa.

Japt, 11 byte

Inizialmente batteva Pyth, ma apparentemente non funzionava per l'input 0.

1+1oU+B ¬bU

Provalo online!

Come funziona

1+1oU+B ¬ bU
1+1oU+B q bU  // Implicit: U = input integer
  1oU+B       // Generate the range [0, U+11).
        q bU  // Join and take the index of U.
1+            // Add one to get the correct result.
              // Implicit: output last expression

Lua, 54 byte

s=""for i=1,1e4 do s=s..i end print(s:find(io.read()))

Nota: attualmente questo programma stampa sia la prima occorrenza del primo carattere della stringa, sia il punto in cui termina. Se ciò non è consentito, costerà qualche byte in più. Vorrei richiedere un bonus perché il mio programma stampa sia la prima posizione che l'ultima posizione del numero di input.

MATL , 22 byte

it10+:Yst' '=~)wYsXf1)

Prendi l'input ( i), crea il vettore 1 in input + 10 ( 10+:), converte il vettore in una stringa ( Ys) e rimuovi gli spazi, che è doloroso, ( t' '=~)). Quindi, converti l'input in una stringa ( Ys), trova dove si trova la stringa di input nella stringa di numeri ( Xf) e prendi la prima posizione ( 1)). La t's e w' s manipolano la pila (duplicare e di swap, rispettivamente).

PowerShell, 39 44 byte

[Modifica: la mia ipotesi non regge, la costruzione di un array da 1-0 non trova 0 al posto 11. Invece, costruisci da 1-x + 10 per gestire anche 0, ora 44 byte]

param($i)(1..($i+10)-join'').IndexOf("$i")+1

Troverai sempre x quando costruisci una stringa della costante di Champernowne all'ultimo punto quando aggiungi x alla fine, quindi un array da 1-x avrà sempre la risposta in essa. La domanda diventa "si verifica prima?" . Questo codice

param($i)(1..$i-join'').IndexOf("$i")+1

e.g.

PS C:\Temp> .\Champer.ps1 20
30

genera un intervallo di numeri, lo lancia in una stringa e cerca il parametro al suo interno. Poiché PowerShell è una shell orientata agli oggetti, il parametro è in realtà un [int]tipo, quindi provare a salvare due caratteri con .IndexOf($i)cercherebbe un numero intero nella stringa e non troverebbe nulla. Ecco perché uso l'interpolazione di stringhe "$i".

MATL (versione 1.0.1), 22 byte

iXK10+:"@Ys]N$hKYsXf1)

Esempio

>> matl iXK10+:"@Ys]N$hKYsXf1)
> 333
56

Spiegazione

i       % Input
XK      % Copy to clipboard K            
10+     % Add 10. This is needed in case input is 0
:       % Vector of equally spaced values, starting from 1
"       % For each
  @Ys   %   For loop variable as a string
]       % End                            
N$h     % Horizontal concatenation of all stack contents
KYs     % Paste from clipboard K (input number) and convert to string
Xf      % Find one string within another 
1)      % First value

MATL (versione 20.8.0), 16 byte (sfida postdate lingua)

Ringraziamo @Giuseppe per questa versione del programma (leggermente modificata)

10+:"@V]&hGVXf1)

Provalo online!

Spiegazione

10+     % Implicit Input. Add 10. This is needed in case input is 0 
:       % Vector of equally spaced values, starting from 1
"       % For each
  @V    %   For loop variable as a string 
]       % End
&h      % Horizontal concatenation of all stack contents
GV      % Paste from automatic clipboard G (input number) and convert to string
Xf      % Find one string within another 
1)      % First value

PowerShell, 54 50 byte

for($c='';!($x=$c.IndexOf("$args")+1)){$c+=++$i}$x

Grazie a TessellatingHeckler per l'idea di scambiare il whileloop con un forloop.

Esegue tramite un forloop. Come con altre lingue, la prima istruzione nel ciclo può costruire variabili e assegnazioni, quindi inizia con $cuguale solo alla stringa vuota in ''modo da avere l'indicizzazione zero della stringa in linea con l'indicizzazione decimale della sfida. Siamo quindi in un ciclo che controlla se $cha l'input intero ($args ) da qualche parte al suo interno (cioè, poiché .IndexOf()ritorna -1se la stringa non viene trovata, ne aggiungiamo una a quella ( 0) e non a ( $TRUE) per continuare il ciclo). Se non viene trovato, aggiungiamo la nostra $ivariabile contatore pre-incrementata , quindi ricontrolliamo la stringa. Una volta trovata la stringa, .IndexOf()restituirà un valore positivo, il cui non sarà$FALSE, uscendo dal circuito. Infine, abbiamo generato l'indice con $x.

JavaScript (ES6), 40 byte

x=>(f=n=>n?f(n-1)+n:" ")(x+11).search(x)

Utilizza la funzione ricorsiva fper evitare loop. Il metodo di ricerca funziona allo stesso modo indexOftranne per il fatto che accetta RegExp come parametro, il che è irrilevante per questa sfida.

L'aggiunta di a " "for the n=0case (zero è falsy in JS) costringe +a eseguire la concatenazione di stringhe anziché l'aggiunta e corregge l'indicizzazione in base zero.

Python 3, 54.

print(''.join(map(str,range(1,9**7))).find(input())+1)

CJam, 11 byte

r_i),s\#Be|

Provalo qui.

Sto trovando la posizione di Nnella stringa 01234...Nper tenere conto dell'indicizzazione basata su 1. Infine risolto 0applicando OR logico con 11.

Scherzi a parte, 13 byte

;≈9u+R`$`MΣí

Accetta l'input come numero intero. Contiene non stampabili, quindi hexdump:

0c3bf739752b526024604de4a1

Provalo online

Spiegazione:

;≈9u+R`$`MΣí
<form feed>   push str(input)
;≈9u+R        dupe, push [1,...,input+10]
      `$`MΣ   string concatenation of list
           í  get index of input

𝔼𝕊𝕄𝕚𝕟, 13 caratteri / 22 byte

1+⩥(1,ï+ḋ)⨝ÿï

Try it here (Firefox only).

k4, 21 byte

{*1+(,/$1+!10+x)ss$x}

Stesso algoritmo di tutti gli altri: concatena [1..10+x]come stringhe, cerca x come stringa, converti in indicizzazione a una base, restituisce il primo colpo.

Verifica dei casi di test:

  &/20 4 30 56 11 48={*1+(,/$1+!10+x)ss$x}'15 45 20 333 0 2930
1b

Mathematica, 101 byte

(If[#==0,11,m=Min@SequencePosition[s=Flatten[(K=IntegerDigits)/@Range[0,#]],K@#];Length@s[[;;m-1]]])&

Haskell , 82 73 55 byte

Migrato dal duplicato

x!b|or$zipWith(==)x b=0
x!(_:b)=1+x!b
(!(show=<<[1..]))

Provalo online!

Spiegazione

Per prima cosa definiamo !. x!btronca balla prima apparizione di x. Lo fa controllando se binizia con x( or$zipWith(==)x b) restituendo xse lo fa e spostandolo in basso nella stringa altrimenti. Quindi definiamo la nostra funzione principale. La nostra funzione principale è una funzione senza punti che prende la costante ( show=<<[1..]) e la tronca alla prima apparizione di x. Questo prende xcome una stringa.

05AB1E , 6 byte (non concorrenti)

nLJsk>

Provalo online!

JavaScript (ES6), 50 39 38 byte

x=s=``
f=n=>-~s.search(n)||f(n,s+=++x)

Provalo

x=s=``
f=n=>-~s.search(n)||f(n,s+=++x)
o.innerText=f(i.value=15);oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o></pre>

Gelatina , 5 byte

+⁵RVw

Provalo online!

Stax , 6 byte

⌐╛∙#»▓

Esegui ed esegui il debug

Perl 6 , 26 byte

{[~](0..$_).index($_)||11}

Provalo online!

Trova l'indice dell'elemento nell'intervallo concatenato da 0 a quell'elemento o 11se il numero è zero

Perl 5 , 42 + 1 (-p) = 43 byte

(join'',0..$_+10)=~/^(0.*?)$_/;$_=length$1

Provalo online!

Spiegazione

(join'',0..$_+10)   #concatenate all of the numbers from 0 to 10 over the input
=~/^(0.*?)$_/;      #skip the first 0, then find the input
$_=length$1         #the length of the string preceding the input is the answer

Perl 6 / Rakudo 29 byte

{$_~=$++until /(.+)$^a/;$0.chars}

Definisce una funzione con un input ($ ^ a). Chiama così:

say {$_~=$++until /(.+)$^a/;$0.chars}(333)
> 56

Aggiungendo $, una variabile anonima, incrementando $++fino a quando non $^aviene trovato l'input , quindi contando il numero di caratteri prima di esso. Richiedere almeno 1 carattere prima di esso .+nel regex esclude utilmente il caso 0-> 0

J, 30 byte

{.I.(":E.[:}.' '-.~":@i.@+&11)

Probabilmente potrebbe essere ridotto un po 'di più, in particolare concatenando i primi n + 10 numeri interi.

Spiegazione:

{.I.(":E.[:}.' '-.~":@i.@+&11)
                      i.@+&11   | Integers 0 to n+10
                   ":@          | Format list to string
             ' '-.~             | Strip spaces
           }.                   | Behead (remove leading 0)
         [:                     | Cap (previous verbs executed in order, not as a fork)
     ":E.                       | Find matches to the string n (returns a boolean vector)
  I.                            | Indexes of 1s
{.                              | Take only the first

Si noti che questo è indicizzato 0. Esempi:

    {.I.(":E.[:}.' '-.~":@i.@+&11) 1
0
    {.I.(":E.[:}.' '-.~":@i.@+&11) 0
10
    {.I.(":E.[:}.' '-.~":@i.@+&11) 333
55

Buccia , 6 byte

€ΣmdNd

Provalo online!

€         The 1-based index in
 Σ        the list of concatenated
   d      decimal digits
  m N     of every natural number
     d    of the decimal digits of
          the input.