考虑按顺序串联在一起的所有非负十进制整数的无限字符串（类似于Champernowne的常量）：

0123456789101112131415161718192021222324252627282930...979899100101102103...

编写一个程序或函数，该程序或函数采用一个非负整数，该整数将索引（从0开始）到该无限字符串中。输出一个truthy如果数字索引值为0，否则输出一个falsy如果数字为1-9的值。

以字节为单位的最短代码获胜。

前25个产生真实性的输入是：

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

如果您的程序具有较高的内存效率，则表示荣誉，但这不是必需的。

Haskell，25个字节

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

用法示例：(<'1').((show=<<[0..])!!) 312->True

05AB1E，5个字节

码：

ÝJ¹è_

说明：

Ý      # 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).

使用CP-1252编码。在线尝试！

Mathematica，42个 40字节

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

匿名函数。将数字作为输入并返回True或False作为输出。更长但更有效的解决方案：

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

CJam，9个字节

{_),s=~!}

这是一个未命名的块（函数），它吸收一个整数并相应地返回0或1。

说明：

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

在线口译员。请注意，将~评估一个块。或者，您可以运行此测试套件，该套件,用于过滤真实值的前1000个数字。

MATL，11个字节

Qt:qVXzw)U~

在线尝试！

说明：

    % 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字节

2个字节感谢Fatalize。

y@ec:?m0

在线尝试！

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个字节

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

一个以数字作为输入并返回True或的lambda False。

内存效率高。

怎么运行的

1. 0..* –构造从0到无穷大的范围。
2. map(|*.comb, )–延迟迭代范围，将每个数字替换为其字符串表示形式的字符，然后返回新的延迟序列。在|保持新的序列夷为平地。
3. [$_]–将元素放在由（隐式声明的）lambda参数定义的索引处$_。
4. +–将其强制为数字。（需要执行此步骤，因为直接将字符串强制转换为布尔值始终为True，除非该字符串为空。）
5. ! –将其强制为布尔值并取反。

（在线尝试）

编辑：-1字节感谢b2gills。

果冻，6 个字节

RDF⁸ị¬

在线尝试！或验证所有测试用例。

怎么运行的

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个字节

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

在repl.it上对其进行测试。

怎么运行的

对于输入n，'%d'*-~n重复格式字符串n +1次。

(*range(n),n)解压缩范围[0，...，n-1]并生成元组（0，...，n）。

...%...用范围内的相应整数替换％d的每次出现，产生字符串01234567891011 ... n。

(...)[n]<'1'选择索引n处的字符并测试它是否小于字符1。

Python 3，44个字节

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

一个匿名函数，它通过参数接受输入并返回True或False适当地返回。

怎么运行的

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

在Ideone上尝试

Pyth，8个 7字节

感谢@LeakyNun -1个字节

!s@jkUh

这是我在Pyth打高尔夫球的第一次尝试。

完整的程序可以打印True或False根据需要进行打印。

在线尝试

前25个真实输入

怎么运行的

!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字节

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

在线尝试！

仅使用5个整数，最大内存效率\ o /

说明

我们生成的数字与Champernowne常数输入的数字相同。

在主循环中，我们执行以下操作：

• 通过将floor_重复除以10直到达到0，来找到当前数字的长度，然后计算所使用的除法数。
• 而不是存储除法数，而是将10乘以该数次幂。
• 迭代通过每个数字为这样：所述100第位数1234被获得(1234/10)%10，其中/是地板分裂。
• 对于生成的每个数字，从输入中取1，同时检查输入是否达到零。
• 如果输入达到零，请检查当前数字是否为0，然后暂停。

JavaScript（ES6），45字节+荣誉

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

我最好的非Kudos版本是34个字节：

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

JavaScript（ES6），47个字节

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

Javascript（ES6），42 33字节

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

例：

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个字节

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

没什么花哨的，但是我正在尝试一些新的东西。

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个字节

包括+1的 -p

使用STDIN上的输入运行：

zero.pl <<< 31

打印1为零，否则不打印

zero.pl

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

PHP，36字节

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

打印1如果Champernowne说法个十进制是0，否则打印“”（空字符串）。

Ruby，35个 23字节

这是一个匿名函数，可以串联[0..n]，获取nth索引并检查char是否"0"小于（"1"）。欢迎打高尔夫球。

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

开球

->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").

其实9 8字节

此答案连接范围[0..n]，获取nth索引并检查char是否为"0"。欢迎打高尔夫球。在线尝试！

;urεjE≈Y

开球

;          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个字节

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

输出为非空（真实）或空（虚假）。在Ideone上进行测试。

朱莉娅21 20字节

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

感谢@LuisMendo打高尔夫球1个字节！

在线尝试！

R，61 57字节

感谢@plannapus提供了4个字节。

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

创建一个数字0：n的向量（用于0索引），创建一个数字字符串，从字符串中提取第n个值（针对0索引进行调整）。转换为数值并测试其是否为0。

GolfScript，12个字节

~.),""*\=48=

说明：

~             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?

在线尝试或验证所有测试用例！

C，154字节

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

计算值的函数是f（n，0,0,0），其中n是输入索引。它可以通过更改索引“ return！c”或“ return c”中的值来计算该索引中数组的值...

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字节

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

取消高尔夫：

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

旧：

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

未打高尔夫球的旧车：

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个字节

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个字节

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

exit 0 在zsh中是正确的

C＃，71个字节

我以为一开始很短，但是后来我不得不加进去n+=11以防止System.IndexOutOfRangeException当输入的数字小于11时抛出一个a

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

Pyke，7个字节

m`sQ@b!

在这里尝试！