Nó khá đơn giản để, đưa ra một số n, tạo một phạm vi từ 0đến n-1. Trong thực tế, nhiều ngôn ngữ cung cấp hoạt động này như là một nội dung.

Chương trình CJam sau đây đọc một số nguyên, sau đó in ra một phạm vi như vậy ( Thử trực tuyến! ):

ri,

Lưu ý rằng nó in ra các số mà không có dấu phân cách.

Các thách thức

Nhiệm vụ của bạn là đảo ngược quá trình này. Bạn nên viết một chương trình, đưa ra một chuỗi đại diện cho một phạm vi, trả về số được sử dụng để tạo ra phạm vi đó.

Thông số kỹ thuật

• Các con số được đưa ra mà không có bất kỳ dấu phân cách.
• Bạn có thể giả sử chuỗi tạo thành một phạm vi hợp lệ.
• Bạn có thể sử dụng lập chỉ mục dựa trên 0 hoặc 1 cho phạm vi của mình.
• Bạn có thể cho rằng một đầu ra chính xác sẽ không bao giờ vượt quá 32.767 (vì vậy, một đầu vào hợp lệ sẽ không bao giờ có độ dài lớn hơn 152.725).
• Bạn có thể cho rằng một đầu ra chính xác sẽ luôn dương (vì vậy bạn không phải xử lý 0 hoặc âm).

Đây là môn đánh gôn , vì vậy câu trả lời cạnh tranh ngắn nhất (tính bằng byte) sẽ thắng.

Các trường hợp thử nghiệm

Chỉ số 0:

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

1 chỉ mục:

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

Prolog (SWI) , 91 80 byte

Chỉ số 0.

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

Dòng mới được thêm vào để dễ đọc.

Hãy thử trực tuyến!

Husk , 5 byte

LCmLN

Hãy thử trực tuyến!

Chỉ những lá thư!

Lấy đầu vào dưới dạng chuỗi, kết quả là 1 chỉ mục.

Giải trình

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 byte

1 chỉ mục.

āηJsk>

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

ā        # 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 byte

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

Chỉ số 0

-7 byte nhờ @ PunPun1000 .

Tôi có cảm giác điều này có thể được rút ngắn bằng cách chỉ kiểm tra độ dài của đầu vào bằng cách nào đó, vì chúng ta có thể giả sử đầu vào luôn hợp lệ. Vẫn đang tìm ra điều này. Không thể tìm ra điều này và có lẽ nó sẽ tốn quá nhiều byte trong Java dù sao cũng có ích (áp dụng tương tự cho việc trả về một chuỗi con ở cuối đầu vào 1 chỉ mục).

Giải trình:

Hãy thử nó ở đây.

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 byte

⟦kṫᵐc,Ẹ

Hãy thử trực tuyến!

Chỉ số 0.

Giải trình

Ở đây chúng ta chuyển đầu vào thông qua biến Đầu ra và truy cập kết quả thông qua biến Đầu vào.

⟦          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 byte

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

Hãy thử trực tuyến!

Không thể tin rằng điều này đã làm việc tốt như nó đã làm ...

Japt , 8 byte

Bắt đầu nắm bắt các phương thức chức năng trong Japt.

Chỉ số 0. Có thể lấy đầu vào dưới dạng chuỗi, số nguyên hoặc mảng chứa 0 hoặc 1 phần tử.

_o ´U}a

Kiểm tra nó

Giải trình

Đầu vào ngầm định của chuỗi U.

_     }a

Lấy số nguyên đầu tiên >=0trả về true khi chuyển qua hàm ...

o

Tạo một mảng các số nguyên từ 01 đến ít hơn số nguyên hiện tại ...

¬

Tham gia nó vào một chuỗi ...

¥U

Kiểm tra chuỗi đó cho bằng U.

Ngõ ra đầu ra của số nguyên kết quả.

Thay thế, 8 byte

ÊÇo ¬ÃbU

Kiểm tra nó

Than , 13 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

          λ     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 byte

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

Chức năng đảo ngược phạm vi dựa trên không.

Cảm ơn Laikoni vì đã tiết kiệm 3 byte!

Hãy thử trực tuyến.

Võng mạc , 30 byte

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

Đệ quy thêm một dấu chấm phẩy sau mỗi số sau đó đếm số dấu chấm phẩy

Hãy thử trực tuyến!

JavaScript (ES6), 32 31 byte

Đã lưu 1 byte nhờ Challenger5

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

Các trường hợp thử nghiệm

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'))

Toán học, 46 byte

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

1 chỉ mục

đầu vào

["12345678910"]

Ruby , 51 50 46 byte

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

(Đây là chương trình Ruby đầu tiên của tôi từ trước đến nay nên dễ dàng đánh gôn hơn nữa)

-4 byte nhờ @Nnnes

Python 2 , 43 byte

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

Hãy thử trực tuyến!

Python 2 , 43 byte

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

Hãy thử trực tuyến!

Python , 46 byte

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

Hãy thử trực tuyến!

Một chiến lược khác. Có một số ký tự từ cuối bằng với độ dài của lần chạy lớn nhất tính 0bằng s.

Python , 46 byte

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

Hãy thử trực tuyến!

Phiên bản đệ quy ở trên.

R , 47 byte

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

Hãy thử trực tuyến!

1 chỉ mục

APL (Dyalog) , 17 11 byte

-6 byte nhờ ngn .

{,\⍕¨⍳≢⍵}⍳⊂

Hãy thử trực tuyến!

⍳⊂ tìm ɩ ndex của toàn bộ đối số trong

{... } kết quả của chức năng ẩn danh này:

 ≢ độ dài của đối số

 ⍳ ntegers cho đến khi

 ⍕¨ định dạng (xâu chuỗi) mỗi

 ,\ tích lũy của những người

Perl 5 , 19 byte

Mã 18 byte + 1 cho -p.

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

Sử dụng lập chỉ mục 1 dựa trên. -7 byte nhờ cách tiếp cận tốt hơn nhiều của @ nwellnhof !

Hãy thử trực tuyến!

Giải trình

$\là một biến đặc biệt được printed tự động sau mỗi câu lệnh, vì vậy bằng cách sử dụng số đó để lưu số của chúng tôi, chúng tôi không cần cập nhật $_(được in tự động như một phần chức năng của -pcờ) để chứa đầu ra mong muốn. Sau đó, trong khi đầu vào bắt đầu $\, hãy loại bỏ nó và redochương trình, một lần nữa tăng $\và thay thế nó. Khi nó không còn tìm thấy số ở đầu chuỗi, chúng ta đã hoàn thành! Cuối cùng, giảm dần $\để chúng ta có số cuối cùng trong phạm vi.

Python 2 , 46 byte

Chỉ số 0

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

Hãy thử trực tuyến!

CJam , 16 byte

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

Hãy thử trực tuyến!

Thay thế 16 byte

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

Hãy thử trực tuyến!

CJam , 13 byte

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

Rất nhiều dấu phẩy ...

Hãy thử trực tuyến!

Giải trình

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 byte

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

Kiểm tra nó

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

Kiểm tra nó

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

Kiểm tra nó

Mở rộng:

{  # 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...*tạo ra một dãy vô hạn các giá trị '', 0,1 , 2, 3...

[\~] '',0...* tạo ra một chuỗi vô hạn của tất cả các đầu vào có thể

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

Lưu ý rằng mã này sẽ không bao giờ dừng nếu bạn cung cấp cho nó một đầu vào không hợp lệ.

Bình thường , 11 10 byte

1 chỉ mục.

fqQ|jkSTk0

Hãy thử nó ở đây

Nếu chuỗi trống có thể bị bỏ qua, điều này có thể rút ngắn xuống còn 6 byte :

fqQjkS

-1 byte nhờ @Mnemonic

CJam, 14 12 11 byte

q,_){,s,}%#

Dùng thử trực tuyến

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 byte

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

Thuật toán tương tự như câu trả lời Java này , ngoại trừ nó (ab) sử dụng một số đặc sản cú pháp của Dyvil.

Giải trình:

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

• Đã lưu 4byte bằng cách sử dụng biểu thức truy cập dấu ngoặc thay vì biến cho bộ tích lũy

MATL , 14 byte

`@q:VXzGX=~}@q

1 chỉ mục.

Hãy thử trực tuyến!

Giải trình

`       % 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 byte

Dữ liệu

• Đầu vào String i Mảng int được giải mã
• Đầu ra Int32 Số được sử dụng để tạo mảng

Chơi gôn

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

Bị đánh cắp

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

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

    return c;
}

Ungolfed có thể đọc đượ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;
}

Mã đầy đủ

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

Phát hành

• v1.0 - 72 bytes- Giải pháp ban đầu.

Ghi chú

• không ai

SOGL V0.12 , 11 10 9 byte

1 chỉ mục.

I∫HΔ∑=?f←

Hãy thử nó ở đây!

Giải trình:

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

.. hoặc 7 byte mà không có trường hợp trống

∫Δ∑=?F←

Hãy thử nó ở đây!

Aceto , 27 25 byte

Chỉ số dựa trên 1.

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

Chúng tôi rđọc đầu vào và Mtạo ra nó (và trực tiếp Ltải lại), sau đó chúng tôi phủ nhận nó ( !; dẫn đến một giá trị trung thực chỉ cho một chuỗi trống). Nếu giá trị này là true ( `), chúng ta sẽ nhảy đến cuối ( ;), trong đó chúng ta psử dụng số 0 ẩn.

Mặt khác, chúng tôi tăng giá trị ngăn xếp hiện tại (ban đầu là 0), sao chép nó và đặt một bản sao trên ngăn xếp sang bên phải, trong khi cũng di chuyển đến đó ( Id]). Sau đó, chúng tôi xây dựng một phạm vi giảm ( z), tham gia ngăn xếp dưới dạng chuỗi ( ¥) và di chuyển giá trị (và chúng tôi) trên ngăn xếp ban đầu một lần nữa ( [). Chúng tôi Ltải giá trị chúng tôi ghi nhớ trước đó (đầu vào) và so sánh nó với chuỗi này. Nếu bằng nhau, chúng ta nhảy đến cuối một lần nữa, nơi chúng ta in giá trị "bộ đếm" hiện tại (=`; ).

Mặt khác, rất nhiều không gian trống được duyệt qua cho đến khi đường cong Hilbert cuối cùng chạm vào <đó đặt IP lên trên Imột lần nữa, tăng bộ đếm và kiểm tra lại.

Xếp chồng lên nhau , 23 byte

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

Hãy thử trực tuyến!

Về cơ bản, tăng 0cho đến khi phạm vi từ 0đến số trông giống như đầu vào, trước tiên hãy kiểm tra sự bằng nhau.

Thạch , 8 byte

JVṾẎ$$Ƥi

Hãy thử trực tuyến!