introduction

En base 10, la constante de Champernowne est définie par la concaténation de représentations de nombres entiers successifs. En base 10: 0.1234567891011121314151617...et ainsi de suite.

Vous pouvez voir que la première apparition de 15commence à la 20thdécimale:

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

La première apparition de 45commence à la 4thdécimale:

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

Donc, la tâche est facile. Pour un nombre entier non négatif, indiquez la position du nombre entier dans la constante de Champernowne.

Règles

• Vous pouvez fournir une fonction ou un programme
• C'est du code-golf , donc la soumission avec le moins d'octets gagne!

Cas de 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

Concatène les premiers input + 10nombres puis trouve l'index basé sur 0 plus un .. Les dix supplémentaires ne sont nécessaires que pour 0.

Suite de tests

LabVIEW, 29 primitives LabVIEW

Cela utilise des chaînes pour le moment. Il correspond à l'entrée sous forme de motif et génère le décalage - (longueur de l'entrée -1).

Javascript, 57 octets

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

Sauvé 1 octet grâce à Conor O'Brien.

Haskell, 62 octets

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

Exemple d'utilisation: (#(show=<<[1..])).show $ 2930-> 48.

Comment ça marche: a # btrouve la position de adans b: si aest le préfixe de bretour 1, sinon ajouter 1à un appel récursif avec a # tail b. La fonction pointfree (#(show=<<[1..])).showattend un argument (non nommé) net des appels show n # show=<<[1..].

La fonction subIndexferait également le travail de #, mais le nécessaire import Data.List.Utilsne paye pas.

Ruby, 28 ans

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

Inclut un 0 au début afin que les correspondances soient indexées sur 1, mais utilise \Bpour exiger que la correspondance ne soit pas au début de la chaîne.

Japt, 11 octets

C'était à l'origine de battre Pyth, mais apparemment cela n'a pas fonctionné pour l'entrée 0.

1+1oU+B ¬bU

Essayez-le en ligne!

Comment ça marche

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 octets

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

Remarque: Actuellement, ce programme imprime à la fois la première occurrence du premier caractère de la chaîne et le point où elle se termine. Si cela n'est pas autorisé, cela coûtera quelques octets supplémentaires. Je voudrais demander un bonus car mon programme imprime à la fois la première et la dernière position du numéro saisi.

MATL , 22 octets

it10+:Yst' '=~)wYsXf1)

Prenez input ( i), transformez le vecteur 1 en entrée + 10 ( 10+:), convertit le vecteur en chaîne ( Ys) et supprimez les espaces, ce qui est douloureux, ( t' '=~)). Ensuite, convertissez l’entrée en chaîne ( Ys), recherchez où se trouve la chaîne d’entrée dans la chaîne de nombres ( Xf) et prenez le premier emplacement ( 1)). Les t'et w' manipulent la pile (dupliquer et échanger, respectivement).

PowerShell, 39 44 octets

[Edit: mon hypothèse ne tient pas, la construction d'un tableau de 1-0 ne trouve pas 0 à la place 11. Au lieu de cela, construisez à partir de 1-x + 10 pour gérer 0 aussi, maintenant 44 octets]

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

Vous trouverez toujours x lors de la création d'une chaîne de la constante de Champernowne au dernier point lorsque vous ajoutez x à la fin. Ainsi, un tableau de 1-x aura toujours la réponse. La question devient "cela se produit-il plus tôt que cela?" . Ce code

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

e.g.

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

génère une plage de nombres, la convertit en chaîne et recherche le paramètre à l'intérieur de celle-ci. Etant donné que PowerShell est un shell orienté objet, le paramètre est en fait un [int]type. Par conséquent, si vous souhaitez enregistrer deux caractères avec .IndexOf($i), rechercher dans la chaîne un entier et ne rien trouver. C'est pourquoi j'utilise l'interpolation de chaîne "$i".

MATL (version 1.0.1), 22 octets

iXK10+:"@Ys]N$hKYsXf1)

Exemple

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

Explication

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 (version 20.8.0), 16 octets (défi du langage postdate)

Merci à @ Giuseppe pour cette version du programme (légèrement modifiée)

10+:"@V]&hGVXf1)

Essayez-le en ligne!

Explication

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 octets

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

Merci à TessellatingHeckler pour l’idée d’échanger la whileboucle contre une forboucle.

S'exécute via une forboucle. Comme avec les autres langages, la première instruction de la boucle peut construire des variables et des assignations. Elle commence donc par $cégale à la chaîne vide, de ''sorte que nous ayons une indexation zéro de la chaîne alignée avec l'indexation décimale du défi. Nous sommes alors dans une boucle qui vérifie si $ca l'entier d'entrée ( $args) quelque part dans (ie, étant donné que le .IndexOf()rendement -1si la chaîne ne se trouve pas, nous ajoutons un à qui ( 0) et pas ( $TRUE) de continuer la boucle). Si ce n'est pas trouvé, nous ajoutons notre $ivariable de compteur pré-incrémentée , puis revérifions la chaîne. Une fois la chaîne trouvée,.IndexOf() retournera une valeur positive, dont le non sera$FALSE, sortir de la boucle. Enfin, nous produisons l'index avec $x.

JavaScript (ES6), 40 octets

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

Utilise la fonction récursive fpour éviter les boucles. La méthode de recherche fonctionne de la même manière, indexOfsauf qu’elle prend RegExp en tant que paramètre, ce qui n’est pas pertinent pour ce défi.

L'ajout d'un " "pour le n=0cas (zéro est faux dans JS) oblige le +à effectuer une concaténation de chaîne au lieu d'un ajout et à corriger l'indexation à zéro.

Python 3, 54.

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

CJam, 11 octets

r_i),s\#Be|

Testez-le ici.

Je trouve la position de Ndans la chaîne 01234...Npour prendre en compte l'indexation basée sur 1. Enfin, je répare 0en appliquant un OU logique avec 11.

Sérieusement, 13 octets

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

Prend l'entrée sous forme d'entier. Contient des éléments non imprimables, donc hexdump:

0c3bf739752b526024604de4a1

Essayez-le en ligne

Explication:

;≈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 caractères / 22 octets

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

Try it here (Firefox only).

k4, 21 octets

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

Même chose que tout le monde: concaténer [1..10+x] tant que chaînes, rechercher x en tant que chaîne, convertir en index sur une base, renvoyer le premier résultat.

Vérification des cas de test:

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

Mathematica, 101 octets

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

Haskell , 82 73 55 octets

Migré du duplicata

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

Essayez-le en ligne!

Explication

Nous définissons d'abord !. x!btronque bà la première apparition de x. Pour ce faire, il vérifie si bcommence avec x( or$zipWith(==)x b) en retournant xsi c'est le cas et en déplaçant un autre dans la chaîne. Ensuite, nous définissons notre fonction principale. Notre fonction principale est une fonction sans point qui prend la constante ( show=<<[1..]) et la tronque à la première apparition de x. Cela prend xcomme une chaîne.

05AB1E , 6 octets (non concurrents)

nLJsk>

Essayez-le en ligne!

JavaScript (ES6), 50 39 38 bytes

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

Try it

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>

Jelly, 5 bytes

+⁵RVw

Try it online!

Stax, 6 bytes

⌐╛∙#»▓

Run and debug it

Perl 6, 26 bytes

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

Try it online!

Finds the index of the element in the concatenated range from 0 to that element, or 11 if the number is a zero

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

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

Try it online!

Explanation

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

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

Defines a function with one input ($^a). Call thus:

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

Appending $, an anonymous variable, incrementing $++ until the input $^a is found, and then counting the number of chars before it. Requiring at least 1 char before it .+ in the regex usefully excludes the 0->0 case

J, 30 Bytes

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

Could probably be golfed down a bit more, specifically in concatenating the first n+10 integers.

Explanation:

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

Note that this is 0-indexed. Examples:

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

Husk, 6 bytes

€ΣmdNd

Try it 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.