É bastante simples, dado um número n, criar um intervalo de 0até n-1. De fato, muitos idiomas fornecem essa operação como incorporada.

O seguinte programa CJam lê um número inteiro e imprime esse intervalo ( Experimente online! ):

ri,

Observe que ele imprime números sem um separador.

O desafio

Sua tarefa é reverter esse processo. Você deve escrever um programa que, dada uma sequência que represente um intervalo, retorne o número usado para produzir esse intervalo.

Especificações

• Os números são fornecidos sem nenhum separador.
• Você pode assumir que a string forma um intervalo válido.
• Você pode usar a indexação com base em 0 ou 1 em seu intervalo.
• Você pode assumir que uma saída correta nunca excederá 32.767 (portanto, uma entrada válida nunca terá um comprimento maior que 152.725).
• Você pode assumir que uma saída correta sempre será positiva (portanto, você não precisa lidar com 0 ou negativo).

Isso é código-golfe , então a resposta mais curta da concorrência (medida em bytes) vence.

Casos de teste

Indexado em 0:

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

1 indexado:

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

Prolog (SWI) , 91 80 bytes

Indexado a 0.

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

Novas linhas adicionadas para facilitar a leitura.

Experimente online!

Casca , 5 bytes

LCmLN

Experimente online!

Apenas letras!

Recebe a entrada como uma sequência, o resultado é 1 indexado.

Explicação

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 bytes

1 indexado.

āηJsk>

Experimente online! ou como um conjunto de testes

Explicação

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

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

Indexado a 0

-7 bytes graças a @ PunPun1000 .

Tenho a sensação de que isso pode ser reduzido, verificando apenas o comprimento da entrada de alguma forma, pois podemos assumir que a entrada é sempre válida. Ainda estou descobrindo isso. Não foi possível descobrir isso, e provavelmente custará muitos bytes em Java para ser útil de qualquer maneira (o mesmo se aplica ao retorno de uma substring no final de uma entrada indexada em 1).

Explicação:

Experimente aqui.

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

Braquilog , 9 7 bytes

⟦kṫᵐc,Ẹ

Experimente online!

Indexado a 0.

Explicação

Aqui passamos a entrada pela variável Output e acessamos o resultado pela variável 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 bytes

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

Experimente online!

Não posso acreditar que isso funcionou tão bem quanto ...

Japonês , 8 bytes

Começando a entender os métodos de função no Japt.

Indexado a 0. Pode receber a entrada como uma string, um número inteiro ou uma matriz contendo 0 ou 1 elementos.

_o ´U}a

Teste-o

Explicação

Entrada implícita da sequência U.

_     }a

Obtenha o primeiro número inteiro >=0que retorna true quando passado por uma função que ...

o

Gera uma matriz de números inteiros de 01 a menos que o número inteiro atual ...

¬

Une-o a uma string ...

¥U

Verifica essa cadeia quanto à igualdade com U.

Saída implícita do número inteiro resultante.

Alternativa, 8 bytes

ÊÇo ¬ÃbU

Teste-o

Carvão vegetal , 13 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

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

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

Função que inverte intervalos com base em zero.

Obrigado a Laikoni por economizar 3 bytes!

Experimente online.

Retina , 30 bytes

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

Adiciona recursivamente um ponto e vírgula após cada número e conta o número de ponto e vírgula

Experimente online!

JavaScript (ES6), 32 31 bytes

Guardado 1 byte graças a Challenger5

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

Casos de teste

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 bytes

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

Indexado 1

entrada

["12345678910"]

Ruby , 51 50 46 bytes

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

(Este é o meu primeiro programa Ruby, por isso deve ser fácil jogar ainda mais)

-4 bytes graças a @Nnnes

Python 2 , 43 bytes

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

Experimente online!

Python 2 , 43 bytes

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

Experimente online!

Python , 46 bytes

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

Experimente online!

Uma estratégia diferente. Pega um número de caracteres no final igual ao comprimento da maior sequência de 0s em s.

Python , 46 bytes

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

Experimente online!

Versão recursiva do acima.

R , 47 bytes

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

Experimente online!

Indexado 1

APL (Dyalog) , 17 11 bytes

-6 bytes graças a ngn .

{,\⍕¨⍳≢⍵}⍳⊂

Experimente online!

⍳⊂ encontre o índice de todo o argumento em

{… } O resultado desta função anônima:

 ≢ comprimento do argumento

 ⍳ Ɩ ntegers até que

 ⍕¨ formato (stringify) cada

 ,\ concatenação cumulativa daqueles

Perl 5 , 19 bytes

Código de 18 bytes + 1 para -p.

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

Usa indexação baseada em 1. -7 bytes, graças ao @ nwellnhof é muito melhor abordagem!

Experimente online!

Explicação

$\é uma variável especial que é printeditada automaticamente após cada instrução, portanto, usando isso para armazenar nosso número, não precisamos atualizar $_(que é impresso automaticamente como parte da funcionalidade do -psinalizador) para conter a saída desejada. Em seguida, enquanto a entrada começa $\, remova-a e redoo programa, que novamente a incrementa $\e a substitui. Quando ele não encontrar mais o número no início da string, estamos prontos! Finalmente, diminua $\para que tenhamos o último número no intervalo.

Python 2 , 46 bytes

Indexado a 0

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

Experimente online!

CJam , 16 bytes

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

Experimente online!

Alternativa 16 bytes

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

Experimente online!

CJam , 13 bytes

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

Tantas vírgulas ...

Experimente online!

Explicação

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 bytes

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

Teste-o

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

Teste-o

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

Teste-o

Expandido:

{  # 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...*produz uma sequência infinita de valores '', 0, 1, 2,3 ...

[\~] '',0...* produz uma sequência infinita de todas as entradas possíveis

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

Observe que esse código nunca será interrompido se você fornecer uma entrada inválida.

Pitão , 11 10 bytes

1 indexado.

fqQ|jkSTk0

Experimente aqui

Se a cadeia vazia puder ser ignorada, isso poderá ser reduzido para 6 bytes :

fqQjkS

-1 byte graças a @Mnemonic

CJam, 14 12 11 bytes

q,_){,s,}%#

Experimente Online

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 bytes

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

O mesmo algoritmo que esta resposta Java , exceto que (ab) usa algumas das especialidades sintáticas de Dyvil.

Explicação:

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

• 4Bytes salvos usando uma expressão de acesso entre chaves em vez de uma variável para o acumulador

MATL , 14 bytes

`@q:VXzGX=~}@q

1 indexado.

Experimente online!

Explicação

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

Dados

• Entrada String i A matriz int a ser decifrada
• Saída Int32 O número usado para criar a matriz

Golfe

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

Ungolfed

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

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

    return c;
}

Ungolfed legible

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

Código completo

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

Lançamentos

• v1.0 - 72 bytes- Solução inicial.

Notas

• Nenhum

SOGL V0.12 , 11 10 9 bytes

1 indexado.

I∫HΔ∑=?f←

Experimente aqui!

Explicação:

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

..ou 7 bytes sem a caixa vazia

∫Δ∑=?F←

Experimente aqui!

Aceto , 27 25 bytes

Índice baseado em 1.

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

Nós rlemos a entrada e a Memorizamos ( e a repetimos diretamente L), depois a negamos ( !; levando a um valor verdadeiro apenas para uma string vazia). Se esse valor for verdade ( `), pularemos para o final ( ;), ondep calcularemos o zero implícito.

Caso contrário, incrementamos o valor atual da pilha (inicialmente um zero), duplicamos e colocamos uma cópia na pilha à direita, enquanto também movemos para lá ( Id]). Em seguida, construímos um intervalo decrescente ( z), juntamos a pilha como uma string ( ¥) e movemos o valor (e nós) na pilha original novamente ( [). Nós LOAD o valor que memorizou mais cedo (a entrada) e compará-lo com este string. Se igual, saltamos para o final novamente, onde imprimimos o valor atual do "contador" (=`; ).

Caso contrário, muito espaço vazio será percorrido até que a curva de Hilbert atinja o <que coloca o IP no topo Inovamente, incrementando o contador e testando novamente.

Empilhados , 23 bytes

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

Experimente online!

Basicamente, incrementa 0até o intervalo de 0até o número parecer com a entrada, verificando primeiro a igualdade.

Geléia , 8 bytes

JVṾẎ$$Ƥi

Experimente online!