Considérez la chaîne infinie de tous les entiers décimaux non négatifs concaténés ensemble dans l'ordre (semblable à la constante de Champernowne ):

0123456789101112131415161718192021222324252627282930...979899100101102103...

Écrivez un programme ou une fonction qui accepte un entier non négatif qui indexe (sur la base de 0) dans cette chaîne infinie. Sortez une valeur vraie si le chiffre indexé est 0, sinon sortez une valeur fausse si le chiffre est 1-9.

Le code le plus court en octets gagne.

Les 25 premières entrées produisant la vérité sont:

0
11
31
51
71
91
111
131
151
171
191
192
194
197
200
203
206
209
212
215
218
222
252
282
312

Bravo si votre programme est efficace en mémoire, mais ce n'est pas une exigence.

Haskell, 25 octets

(<'1').((show=<<[0..])!!)

Exemple d'utilisation: (<'1').((show=<<[0..])!!) 312->True

05AB1E , 5 octets

Code:

ÝJ¹è_

Explication:

Ý      # Get the list [0 .. input].
 J     # Join the list.
  ¹    # Get the first input again.
   è   # Get the character on that index.
    _  # Logical negate (0 -> 1, everything else -> 0).

Utilise l' encodage CP-1252 . Essayez-le en ligne!

Mathematica, 42 40 octets

(0@@Join@@IntegerDigits@Range@#)[[#]]<1&

Fonction anonyme. Prend un nombre en entrée et renvoie soit Trueou Falseen sortie. Une solution plus longue mais plus efficace (?):

RealDigits[ChampernowneNumber[],10,1,-#][[1,1]]<1&

CJam, 9 octets

{_),s=~!}

Il s'agit d'un bloc (fonction) sans nom qui prend un entier et renvoie 0 ou 1 en conséquence.

Explication:

{       }        Defines a block
 _               Copy input n
  ),             Increment n and take range
    s            Convert to string - for a list of numbers this concatenates
                 the digits
     =           Index, getting nth digit
      ~          Evaluate the digit character into a number
       !         Logical negation

Interprète en ligne . Notez que ~évalue un bloc. Alternativement, vous pouvez exécuter cette suite de tests qui utilise ,pour filtrer les 1000 premiers nombres pour les valeurs véridiques.

MATL, 11 octets

Qt:qVXzw)U~

Essayez-le en ligne!

Explication :

    % Implicitly grab input as an integer (N)
Qt  % Add 1 and duplicate
:q  % Create an array from [0 ... N]
V   % Convert each entry to a string (places spaces between each number)
Xz  % Remove all whitespace
w)  % Get the N+1 element of the string (since MATL uses 1-based indexing natively)
U~  % Convert the result back to a number and negate which yields TRUE if it was '0' and
    % FALSE otherwise

Brachylog , 10 8 octets

2 octets grâce à Fatalize.

y@ec:?m0

Essayez-le en ligne!

y@ec:?m0

y         range from 0 to Input, inclusive,
 @e       the digits of every number in that range,
   c      concatenated
    :?m   the Input-th digit
       0  is zero.

Perl 6 , 26 25 octets

{!+map(|*.comb,0..*)[$_]}

Un lambda qui prend un nombre en entrée et renvoie un True ou False.

Mémoire-efficace.

Comment ça marche

1. 0..* - Construisez la plage de 0 à l'infini.
2. map(|*.comb, )- Itérer par défaut la plage, en remplaçant chaque nombre par les caractères de sa représentation sous forme de chaîne et en renvoyant une nouvelle séquence paresseuse. Le |maintient la nouvelle séquence aplatie.
3. [$_]- Prendre l'élément à l'index défini par le paramètre lambda (déclaré implicitement) $_.
4. + - Contraignez-le à un certain nombre. (Cette étape est nécessaire car la contrainte d'une chaîne directement sur un booléen donne toujours True sauf si la chaîne est vide.)
5. ! - Le contraindre à un booléen et le nier.

( essayez-le en ligne )

EDIT: -1 octet grâce à b2gills.

Gelée , 6 octets

RDF⁸ị¬

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

Comment ça marche

RDF⁸ị¬  Main link. Argument: n

R       Range; yield [1, ..., n].
 D      Decimal; convert all integers in that range to base 10 arrays.
  F     Flatten the result.
   ⁸ị   Extract the digit at index n (1-based).
        This returns 0 if the array is empty (n = 0).
     ¬  Logical NOT; return 1 if the digit is 0, 0 if not.

Python 3.5, 40 octets

lambda n:('%d'*-~n%(*range(n),n))[n]<'1'

Testez - le sur repl.it .

Comment ça marche

Pour l'entrée n , '%d'*-~nrépète la chaîne de format n + 1 fois.

(*range(n),n)décompresse la plage [0, ..., n - 1] et donne le tuple (0, ..., n) .

...%...remplace chaque occurrence de % d par l'entier correspondant dans la plage, ce qui donne la chaîne 01234567891011 ... n .

(...)[n]<'1'sélectionne le caractère à l'index n et teste s'il est inférieur au caractère 1 .

Python 3, 44 octets

lambda n:''.join(map(str,range(n+1)))[n]<'1'

Une fonction anonyme qui prend une entrée via un argument et retourne TrueouFalse selon le cas.

Comment ça marche

lambda n      Anonymous function with input n
range(n+1)    Yield the range [0, n]...
map(str,...)  ...convert all elements to string...
''.join(..)   ...concatenate...
...[n]        ...yield nth character...
:...<'1'      ...return True if int(character)==0 else return False

Essayez-le sur Ideone

Pyth, 8 7 octets

Merci à @LeakyNun pour -1 octet

!s@jkUh

Ceci est ma première tentative de golf en Pyth.

Un programme complet qui imprime Trueou Falseselon le cas.

Essayez-le en ligne

25 premières entrées véridiques

Comment ça marche

!s@jkUh    Program. Input: Q
      hQ   Head. Yield Q+1
     U     Unary range. Yield [0, Q]
   jk      Join. Join on empty string
  @     Q  Index. Yield string[Q]
 s         Integer. Convert to integer
!          Logical negation. 0 -> True, all other digits -> False
           Print. Print result implicitly

SILOS , 141 octets

readIO
i+1
lblL
c=C
p=1
lblc
p*10
c/10
if c c
p/10
lbln
m=C
m/p
m%10
p/10
i-1
if i C
GOTO H
lblC
if p n
C+1
GOTO L
lblH
m/m
m-1
m|
printInt m

Essayez-le en ligne!

Utilise seulement 5 entiers, efficacité maximale de la mémoire \ o /

Explication

Nous générons autant de chiffres que l'entrée dans la constante de Champernowne.

Dans la boucle principale, nous faisons ce qui suit:

• Trouvez la longueur du nombre actuel en le divisant par étage par 10 à plusieurs reprises jusqu'à ce qu'il atteigne 0, puis comptez le nombre de divisions utilisées.
• Au lieu de stocker le nombre de divisions, nous stockons 10 à ce nombre.
• Itérer à travers chaque chiffre en tant que tel: le 100chiffre s de 1234est obtenu par (1234/10)%10où /est la division du plancher.
• Pour chaque chiffre généré, prenez 1 de l'entrée, tout en vérifiant si l'entrée a atteint zéro.
• Si l'entrée atteint zéro, vérifiez si le chiffre actuel est 0, puis arrête.

JavaScript (ES6), 45 octets + félicitations

f=(n,s='0')=>s[n]?!+s[n]:f(n-s.length,-~s+'')

Ma meilleure version non-Kudos était de 34 octets:

n=>!+(g=s=>s[n]||g(s+i++))('',i=0)

JavaScript (ES6), 47 octets

n=>[...Array(n+1)].reduce((a,_,i)=>a+i,'')[n]<1

Javascript (ES6), 42 33 octets

n=>!+(r=i=>i>n?'':i+r(i+1))(0)[n]

Exemple:

let f =
n=>!+(r=i=>i>n?'':i+r(i+1))(0)[n]

// test all integers in [0, 312]
for(var n = 0, list = []; n <= 312; n++) {
  f(n) && list.push(n);
}
console.log(list.join(','));

Groovy, 56 octets

def f(n){def s=''<<'';(0..n).each{s<<it};!(s[n] as int)}

Rien d'extraordinaire, mais j'essaie de nouvelles choses.

def f(n) {
  def s = ''<<''           // declare a StringBuffer
  (0..n).each { s << it }
  !(s[n] as int)           // Groovy considers a non-null char truthy, so we have to cast 
}

Perl, 24 octets

Comprend +1 pour -p

Exécuter avec entrée sur STDIN:

zero.pl <<< 31

imprimer 1 pour zéro, rien d'autre

zero.pl

$_=!(map/./g,0..$_)[$_]

PHP, 36 octets

<?=!join(range(0,$a=$argv[1]))[$a];

Affiche 1si l'argument Champernowne-e décimal est 0, sinon affiche '' (chaîne vide).

Rubis, 35 23 octets

Il s'agit d'une fonction anonyme qui concatène [0..n], prend l' nindex e et vérifie si ce caractère est "0"(inférieur à "1"). Suggestions de golf bienvenues.

->n{([*0..n]*'')[n]<?1}

Ungolfing

->n{...}   # Create an anonymous function with parameter n.
[*0..n]    # Create an array of the range [0..n].
[...]*''   # Join the array using the empty string.
(...)[n]   # Take the char at the n-th index of the string.
<?1        # Check if the char is < "1" (that is, "0").

En fait, 9 8 octets

Cette réponse concatène la plage [0..n], prend l' nindex e et vérifie si ce caractère est "0". Suggestions de golf bienvenues. Essayez-le en ligne!

;urεjE≈Y

Ungolfing

;          Duplicate n
 ur        Increment the duplicate and create range [0..n].
   εj      Join the range with an empty string. Stack: <string> n
     E     Take the char at the n-th index.
      ≈    int(a)
       Y   Logical NOT. If the digit is 0, then return 1, else return 0.

Bash, 31 28 octets

seq -s "" 0 $1|egrep ^.{$1}0

La sortie est non vide (véridique) ou vide (fausse). Testez-le sur Ideone .

Julia, 21 20 octets

!n=join(0:n)[n+1]<49

Merci à @LuisMendo d'avoir joué au golf sur 1 octet!

Essayez-le en ligne!

R, 61 57 octets

Merci à @plannapus pour 4 octets.

n=scan();strsplit(paste(0:n,collapse=""),"")[[1]][n+1]==0

Crée un vecteur de nombres 0: n (pour l'indexation 0), crée une chaîne d'entre eux, extrait la nième valeur de la chaîne (ajustement pour l'indexation 0). Convertit en numérique et teste s'il est 0.

GolfScript, 12 octets

~.),""*\=48=

Explication:

~             Evaluate the input.
 .            Duplicate it
  )           Increment the duplicate.
   ,          Create an array from 0 to it.
    ""*       Join it with an empty string.
       \=     Get the n-th index of this string, where n is the input
         48=  Is it equal to 0?

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

C, 154 octets

s(n,v,k,z){for(k=1;(z=n%10,n/=10)&&!v||k<v;++k); return v?z:k;}
f(n,i,j,c){for(i=0,j=0;;++i){c=s(i,0,0,0);j+=c;if(j>n){c=s(i,j-n,c,0);break;}}return !c;}

la fonction qui calcule la valeur est f (n, 0,0,0) où n est l'indice d'entrée. il peut calculer à partir de l'index en changeant "return! c" dans "return c" la valeur du tableau dans cet index ... je ne comprends pas comment mais cela semble fonctionner ok ....

main()
{int   i,r;
 char  a[]="0123456789101112131415161718192021222324252627282930313233343536";

 for(i=0; i<1000; ++i) 
    if(r=f(i,0,0,0))  
        printf("%u|",i);
}
/*
 154
 0|11|31|51|71|91|111|131|151|171|191|192|194|197|200|203|206|209|212|215|218|222
|252|282|312|342|372|402|432|462|491|492|494|497|500|503|506|509|512|515|518|522|552
|582|612|642|672|702|732|762|791|792|794|797|800|803|806|809|812|815|818|822|852
|882|912|942|972|
*/

Javascript (ES5): 61 60 octets

function(b){for(s="";s.length<b;)s+=s.length;return 0==s[b]}

Non golfé:

function a(b){
  for(var s="";s.length<b;)
    s+=s.length;
  }
  return (s[b]==0);
}

Vieux:

function(n){s="";while(s.length<n)s+=s.length;return s[n]==0}

Vieux non golfé:

function a(n){
  var str="";
  while(str.length<n)str+=str.length; //Create String as long as needed
  return str[n]==0 //Check for 0 and return
}

CoffeeScript, 56 octets

a=(b)->
 s=""
 while s.length<b #loop for building string with required length
  s+=s.length     #add number
 "0"==s[b]        #return, if the number at the position equals zero

zsh, 31 octets

exit ${${(j..):-{0..$1}}[$1+1]}

exit 0 est vrai dans zsh

C #, 71 octets

Et je pensais que c'était court au début, mais ensuite j'ai dû ajouter n+=11pour l'empêcher de lancer un System.IndexOutOfRangeExceptionlorsque des nombres inférieurs à 11 étaient entrés

return String.Join("",Enumerable.Range(0,n+=11).ToArray())[n]=='0'?1:0;

Pyke, 7 octets

m`sQ@b!

Essayez-le ici!