给定一个数字n，创建从0到的范围非常简单n-1。实际上，许多语言都以内置方式提供此操作。

以下CJam程序读取一个整数，然后打印出这样的范围（请在线尝试！）：

ri,

请注意，它打印出没有分隔符的数字。

挑战

您的任务是逆转此过程。您应该编写一个程序，给定一个代表范围的字符串，该程序返回用于产生该范围的数字。

技术指标

• 给出的数字没有任何分隔符。
• 您可以假定该字符串形成有效范围。
• 您可以为范围使用基于0或1的索引。
• 您可以假设正确的输出将永远不会超过32,767（因此有效输入的长度永远不会超过152,725）。
• 您可以假设正确的输出将始终为正（因此您不必处理0或负）。

这是代码高尔夫球，因此最短的竞争性答案（以字节为单位）获胜。

测试用例

0索引：

0123 -> 4
0 -> 1
0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100 -> 101

1索引：

1234 -> 4
1 -> 1
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100 -> 100

Prolog（SWI），91 80字节

0索引。

X*L:-atom_length(X,L),
     between(0,L,Y),
     numlist(0,Y,B),
     atomic_list_concat(B,X)
     ;L=0.

添加了换行符以提高可读性。

在线尝试！

外壳，5个字节

LCmLN

在线尝试！

只有字母！

将输入作为字符串，结果为1索引。

说明

LCmLN
  mLN    get the list of lengths of all positive naturals
 C       cut the input into slices of those lengths
L        get the length of the resulting list

05AB1E，7 6字节

1个索引。

āηJsk>

在线尝试！ 或作为测试套件

说明

ā        # push range [1 ... len(input)]
 η       # compute prefixes of the range
  J      # join each prefix to a string
   sk    # get index of the input in the list of prefixes
     >   # increment

Java 8，66 59字节

s->{int r=0;for(String c="";!c.equals(s);c+=r++);return r;}

0索引

-7个字节，感谢@ PunPun1000。

我觉得可以通过仅检查输入长度来缩短此时间，因为我们可以假定输入始终有效。仍在弄清楚这一点。无法弄清楚这一点，无论如何它在Java中可能会花费太多字节而无用（对返回1索引输入末尾的子字符串也是如此）。

说明：

在这里尝试。

s->{                 // Method with String parameter and integer return-type
  int r=0;           //  Result-integer
  for(String c="";   //  Check-String
      !c.equals(s);  //  Loop as long as the sum-String doesn't equal the input-String
    c+=r++           //   Append the number to the the Check-String,
                     //   and increase the Result-integer by 1
  );                 //  End of loop
  return r;          //  Return the result-integer
}                    // End of method

Brachylog，9 岁 7字节

⟦kṫᵐc,Ẹ

在线尝试！

0索引。

说明

在这里，我们通过Output变量传递输入，并通过Input变量访问结果。

⟦          The result is the input to a range…
 k         …with the last element removed…
  ṫᵐ       …which when all elements are casted to string…
    c      …and are then concatenated results in the input string
     ,Ẹ    (Append the empty string, this is necessary for it to work in the case where the 
             input is the empty string)

Ly，29个字节

iys&p>0<11[ppl>s1+<lfspSylL]>

在线尝试！

简直不敢相信这会像以前一样有效...

杰普特，8字节

开始精通Japt中的函数方法。

0索引。可以将输入作为字符串，整数或包含0或1个元素的数组。

_o ´U}a

测试一下

说明

字符串的隐式输入U。

_     }a

获取>=0通过函数传递时返回true 的第一个整数...

o

生成一个整数数组，该整数数组0比当前整数小到。

¬

将其连接到字符串...

¥U

检查该字符串是否相等 U。

结果整数的隐式输出。

备用，8字节

ÊÇo ¬ÃbU

测试一下

木炭，13字节

Ｉ⌕Ｅ⁺ψθ⪫ＥκＩλωθ

在线尝试！链接是详细版本的代码。说明：

          λ     Inner map variable (μ inner map index also works)
         Ｉ      Cast to string
        κ       Outer map index
       Ｅ        Map over implicit range
      ⪫    ω    Join result
     θ          Input string
   ⁺ψ           Plus an extra character
  Ｅ             Map over each character
 ⌕          θ   Find the index of the original string
Ｉ               Cast from integer to string
                Implicit print

Haskell，40 37字节

f s=[n|n<-[0..],(show=<<[0..n])>s]!!0

反转从零开始的范围的功能。

感谢Laikoni节省了3个字节！

在线尝试。

视网膜，30字节

+1`(\d+?)(?!\D)(?<!\1.+)
$0;
;

在每个数字后递归添加一个分号，然后计算分号的数量

在线尝试！

JavaScript（ES6），32 31字节

由于Challenger5，节省了1个字节

f=(s,r=n='')=>r<s?f(s,r+n++):+n

测试用例

f=(s,r=n='')=>r<s?f(s,r+n++):+n

console.log(f('0123'))
console.log(f('0'))
console.log(f(''))
console.log(f('0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100'))

Mathematica，46个字节

Array[""<>ToString/@Range@#&,2^15]~Position~#&

1索引

输入

[“ 12345678910”]

红宝石，51 50 46字节

->n{(0..4e4).map{|x|(1..x).to_a.join}.index n}

（这是我有史以来第一个Ruby程序，因此必须很容易进行进一步的开发）

-4个字节，感谢@Nnnes

Python 2，43个字节

f=lambda s,i=1,r='':r<s and-~f(s,i+1,r+`i`)

在线尝试！

Python 2，43个字节

f=lambda s,i=1:s>''and-~f(s[len(`i`):],i+1)

在线尝试！

Python，46个字节

lambda s:s[-sum(i*'0'in s for i in range(5)):]

在线尝试！

不同的策略。从结尾处获取的字符数等于0s中最大的s 长度。

Python，46个字节

f=lambda s,c=0:c*'0'in s and f(s,c+1)or s[-c:]

在线尝试！

上面的递归版本。

R，47个字节

n=nchar(scan(,""));which(cumsum(nchar(1:n))==n)

在线尝试！

1索引

APL（Dyalog），17 11字节

-6个字节感谢ngn。

{,\⍕¨⍳≢⍵}⍳⊂

在线尝试！

⍳⊂ 在中找到整个参数的the ndex

{… } 此匿名函数的结果：

 ≢ 参数的长度

 ⍳ ɩ直到

 ⍕¨ 格式化（字符串化）每个

 ,\ 这些的累积级联

Perl 5，19个字节

18个字节的代码+ 1 for -p。

$i++while s/$i\B//

使用基于1的索引。-7字节感谢@ nwellnhof的很多更好的方法！

在线尝试！

说明

$\是一个特殊变量，print在每个语句后都会自动进行编辑，因此，通过使用该变量来存储我们的数字，我们就不需要更新$_（作为-p标志功能的一部分自动打印）以包含所需的输出。然后，尽管输入以开头$\，请将其删除并redo程序，程序将再次递增$\并替换它。当它不再在字符串开头找到数字时，我们就完成了！最后，递减，$\以便我们获得范围中的最后一个数字。

Python 2，46个字节

0索引

l=lambda x,z="",y=0:z<x and l(x,z+`y`,y+1)or y

在线尝试！

CJam，16字节

r0({)_,s2$=!}g\;

在线尝试！

备用16个字节

r:V;0({)_,sV=!}g

在线尝试！

CJam，13个字节

q:Q,),{,sQ=}#

这么多逗号...

在线尝试！

说明

q:Q            Read the input and store it in Q
   ,           Get its length
    ),         Get the range 0..n
      {,sQ=}#  Find the index of the first number in the range to satisfy this block:
       ,        Get the range 0..(number)-1
        s       Stringify it
         Q=     Check if it equals the input

Perl 6的， 30 28  27个字节

{first :k,*eq$_,[\~] '',0...*}

测试一下

{[\~]('',0...*).first($_):k}

测试一下

{first :k,$_,[\~] '',0...*}

测试一下

展开：

{  # bare block lambda with implicit parameter ｢$_｣

  first       # find the first one
  :k,         # return the index into the Seq instead of what matched
  $_          # that matches the input

  # from the following

  [\~]        # triangle reduce using &infix:«~» (string concatenation)

              # a Seq
    '',       #   that starts with an empty Str
    0         #   then a 0
    ...       #   generate values
    *         #   indefinitely
}

'',0...*产生值的无限序列''，0，1，2，3...

[\~] '',0...* 产生所有可能输入的无限序列

""
"0"
"01"
"012"
"0123"
...

请注意，如果您输入无效的代码，它将永远不会停止。

Pyth，11 10字节

1个索引。

fqQ|jkSTk0

在这里尝试

如果可以忽略空字符串，则可以将其缩短为6个字节：

fqQjkS

-1字节感谢@Mnemonic

CJam，14 12 11字节

q,_){,s,}%#

在线尝试

q,   e# Get length of input string
_)   e# Duplicate length, increment by 1
{    e# Generate array by mapping [0,1,2,...,length] using the following function: 
,    e# Generate range [0,x] (x is the int we're mapping)
s    e# Convert range to string (e.g [0,1,2,3] => "0123"
,    e# Get the length of that string
}%   e# Map the int to the length of it's range string
#    e# Return the index of the length of the input string in the generated array

Dyvil，42 38字节

s=>"".{var r=0;while($0!=s)$0++=r++;r}

与这个Java答案相同的算法，除了（ab）使用Dyvil的某些语法特殊性。

说明：

s=>          // starts a lambda expression with one parameter
"".{         // begins a brace access expression, the value before the '.'
             // is available within the braces as a variable named '$0'
var r=0;     // variable with inferred type int
while($0!=s) // while the accumulator $0 does not (structurally) equal s
$0++=r++     // concatenate $0 and the String representation of r,
             // then store the result in $0 and increment r by 1
;            // end of while
r}           // return r as the result of the lambda

• 4通过使用括号访问表达式而不是累加器变量来保存字节

MATL，14个字节

`@q:VXzGX=~}@q

1个索引。

在线尝试！

说明

`       % Do...while
  @     %   Push iteration index (1-based), k
  q     %   Subtract 1: gives k-1
  :     %   Range: [1 2 ... k-1]. Will be empty for k=1
  V     %   Convert to string
  Xz    %   Remove spaces
  G     %   Push input
  X=    %   Are the two strings equal?
  ~     %   Negate. This is the loop condition. If true: next iteration
}       % Finally (execute at the end of the loop)
  @     %   Push k
  q     %   Subtract 1: gives k-1. This is the solution
        % End (implicit). Display (implicit)

C＃，72个字节

数据

• 输入 String i要解密的int数组
• 输出 Int32用于制作数组的数字

打高尔夫球

(string i)=>{int c,p=c=0;for(;p<i.Length;c++)p+=(c+"").Length;return c;}

不打高尔夫球

( string i ) => {
    int
        c,
        p = c = 0;

    for( ; p < i.Length; c++ )
        p += ( c + "" ).Length;

    return c;
}

非高尔夫可读

// Takes the string with the int array
( string i ) => {
    int
        c,         // Counter, it will count how many ints the array has.
        p = c = 0; // Padding, it will help jumping from int to int on the string.

    // Start counting. If 'i' is empty, the 'c' will be 0.
    for( ; p < i.Length; c++ )

        // Increase the number of digits with the length of 'c'.
        p += ( c + "" ).Length;

    // Return the counter.
    return c;
}

完整代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TestBench {
    public static class Program {
        private static Func<String, Int32> f = ( string i ) => {
            int
                c,
                p = c = 0;

            for( ; p < i.Length; c++ )
                p += ( c + "" ).Length;

            return c;
        };

        static void Main( string[] args ) {
            List<String>
                testCases = new List<String>() {
                    "0123",
                    "0",
                    "",
                    "0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
                };

            foreach(String testCase in testCases) {
                Console.WriteLine($" Input: {testCase}\nOutput: {f(testCase)}\n");
            }

            Console.ReadLine();
        }
    }
}

发布

• 1.0 - 72 bytes-初始溶液。

笔记

• 没有

SOGL V0.12，11 10 9 个字节

1个索引。

I∫HΔ∑=?f←

在这里尝试！

说明：

I∫         repeat input+1 times
  HΔ         create a range from 1 to the 0-indexed iteration, inclusive
    ∑        join it
     =?      if it's equal to the input
       f←      exit, pushing the 0-indexed counter

..或7个字节，不包含空白

∫Δ∑=?F←

在这里尝试！

Aceto，27 25字节

从1开始的索引。

;L[¥
`=]z
MLdI<
r!`;   p

我们r对输入进行ead并将其Memorize（L然后再次!对其进行oad ），然后对它求反（;导致仅对空字符串产生真实值）。如果该值为真（`），则跳到结尾（;），p隐含零。

否则，我们将增加当前堆栈值（最初为零），将其复制，然后将一个副本放到右边的堆栈上，同时也移到那里（Id]）。然后，我们构造一个递减范围（z），将堆栈作为字符串（¥）加入，然后将值（和我们）再次移到原始堆栈上（[）。我们L将存储先前存储的值（输入），并将其与此字符串进行比较。如果相等，我们再次跳到末尾，在此打印当前的“计数器”值（=`;）。

否则，将遍历大量空白空间，直到希尔伯特曲线最终达到，<这将使IP I再次位于顶部，增加计数器并再次进行测试。

堆叠，23字节

{!0$#+[::>''#`n=]until}

在线尝试！

基本上，递增 0直到从0到数字的范围看起来像输入一样，首先检查是否相等。

果冻，8字节

JVṾẎ$$Ƥi

在线尝试！