Es bastante simple, dado un número n, crear un rango de 0a n-1. De hecho, muchos idiomas proporcionan esta operación como una función integrada.

El siguiente programa CJam lee un número entero y luego imprime dicho rango (¡ Pruébelo en línea! ):

ri,

Observe que imprime números sin un separador.

El reto

Su tarea es revertir este proceso. Debería escribir un programa que, dada una cadena que representa un rango, devuelva el número utilizado para producir ese rango.

Presupuesto

• Los números se dan sin ningún separador.
• Puede suponer que la cadena forma un rango válido.
• Puede usar indexación basada en 0 o 1 para su rango.
• Puede suponer que una salida correcta nunca superará los 32.767 (por lo que una entrada válida nunca tendrá una longitud superior a 152.725).
• Puede suponer que una salida correcta siempre será positiva (por lo que no tiene que manejar 0 o negativo).

Este es el código de golf , por lo que gana la respuesta competitiva más corta (medida en bytes).

Casos de prueba

0 indexado:

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

1 indexado:

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

Prólogo (SWI) , 91 80 bytes

0 indexado.

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

Se agregaron nuevas líneas para facilitar la lectura.

Pruébalo en línea!

Casco , 5 bytes

LCmLN

Pruébalo en línea!

¡Solo cartas!

Toma la entrada como una cadena, el resultado es 1 indexado.

Explicación

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>

Pruébalo en línea! o como un conjunto de pruebas

Explicación

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

0 indexado

-7 bytes gracias a @ PunPun1000 .

Tengo la sensación de que esto se puede acortar solo verificando la longitud de la entrada de alguna manera, ya que podemos suponer que la entrada siempre es válida. Todavía estoy resolviendo esto. No se puede resolver esto, y probablemente costará demasiados bytes en Java para ser útil de todos modos (lo mismo se aplica a devolver una subcadena del final de una entrada indexada 1).

Explicación:

Pruébalo aquí

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 bytes

⟦kṫᵐc,Ẹ

Pruébalo en línea!

0 indexado.

Explicación

Aquí pasamos la entrada a través de la variable Salida y accedemos al resultado a través de la variable Entrada.

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

Pruébalo en línea!

No puedo creer que esto funcionó tan bien como lo hizo ...

Japt , 8 bytes

Comenzando a familiarizarse con los métodos de función en Japt.

0 indexado. Puede tomar la entrada como una cadena, un entero o una matriz que contiene 0 o 1 elementos.

_o ´U}a

Pruébalo

Explicación

Entrada implícita de cadena U.

_     }a

Obtenga el primer entero >=0que devuelve verdadero cuando se pasa a través de una función que ...

o

Genera una matriz de enteros de 0a 1 menos que el entero actual ...

¬

Lo une a una cadena ...

¥U

Comprueba esa cadena para la igualdad con U.

Salida implícita del entero resultante.

Alternativa, 8 bytes

ÊÇo ¬ÃbU

Pruébalo

Carbón , 13 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

          λ     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

Función que invierte los rangos basados ​​en cero.

¡Gracias a Laikoni por guardar 3 bytes!

Pruébalo en línea.

Retina , 30 bytes

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

Agrega recursivamente un punto y coma después de cada número y luego cuenta el número de punto y coma

Pruébalo en línea!

JavaScript (ES6), 32 31 bytes

Guardado 1 byte gracias a Challenger5

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

Casos de prueba

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~#&

1 indexado

entrada

["12345678910"]

Ruby , 51 50 46 bytes

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

(Este es mi primer programa Ruby, por lo que debe ser fácil jugarlo más)

-4 bytes gracias a @Nnnes

Python 2 , 43 bytes

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

Pruébalo en línea!

Python 2 , 43 bytes

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

Pruébalo en línea!

Python , 46 bytes

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

Pruébalo en línea!

Una estrategia diferente Toma una cantidad de caracteres del final igual a la longitud de la mayor serie de 0's en s.

Python , 46 bytes

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

Pruébalo en línea!

Versión recursiva de lo anterior.

R , 47 bytes

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

Pruébalo en línea!

1 indexado

APL (Dyalog) , 17 11 bytes

-6 bytes gracias a ngn .

{,\⍕¨⍳≢⍵}⍳⊂

Pruébalo en línea!

⍳⊂ encuentre el índice of de todo el argumento en

{... } el resultado de esta función anónima:

 ≢ longitud del argumento

 ⍳ te dedos hasta eso

 ⍕¨ formatear (stringify) cada

 ,\ concatenación acumulativa de aquellos

Perl 5 , 19 bytes

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

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

Utiliza indexación basada en 1. -7 bytes gracias a @ nwellnhof Es por tanto un mejor enfoque!

Pruébalo en línea!

Explicación

$\es una variable especial que se printedita automáticamente después de cada instrucción, por lo que al usarla para almacenar nuestro número no necesitamos actualizar $_(que se imprime automáticamente como parte de la funcionalidad de la -pbandera) para contener la salida deseada. Luego, mientras la entrada comienza con $\, retírela y redoel programa, que nuevamente la incrementa $\y la reemplaza. Cuando ya no encuentra el número al comienzo de la cadena, ¡hemos terminado! Finalmente, decremente $\para tener el último número en el rango.

Python 2 , 46 bytes

0 indexado

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

Pruébalo en línea!

CJam , 16 bytes

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

Pruébalo en línea!

Alternativa 16 bytes

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

Pruébalo en línea!

CJam , 13 bytes

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

Tantas comas ...

Pruébalo en línea!

Explicación

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...*}

Pruébalo

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

Pruébalo

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

Pruébalo

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...*produce una secuencia infinita de valores '', 0, 1, 2, 3...

[\~] '',0...* produce una secuencia infinita de todas las entradas posibles

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

Tenga en cuenta que este código nunca se detendrá si le da una entrada no válida.

Pyth , 11 10 bytes

1 indexado.

fqQ|jkSTk0

Pruébalo aquí

Si se puede ignorar la cadena vacía, esto se puede acortar a 6 bytes :

fqQjkS

-1 byte gracias a @Mnemonic

CJam, 14 12 11 bytes

q,_){,s,}%#

Pruébalo en línea

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}

El mismo algoritmo que esta respuesta de Java , excepto que (ab) usa algunas de las especialidades sintácticas de Dyvil.

Explicación:

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 guardados utilizando una expresión de acceso de llaves en lugar de una variable para el acumulador

MATL , 14 bytes

`@q:VXzGX=~}@q

1 indexado.

Pruébalo en línea!

Explicación

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

Datos

• Entrada String i La matriz int que se descifrará
• Salida Int32 El número utilizado para hacer la matriz.

Golfed

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

Sin golf

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

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

    return c;
}

Legible sin golf

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

Lanzamientos

• v1.0 - 72 bytes- Solución inicial.

Notas

• Ninguna

SOGL V0.12 , 11 10 9 bytes

1 indexado.

I∫HΔ∑=?f←

Pruébalo aquí!

Explicación:

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

..o 7 bytes sin la caja vacía

∫Δ∑=?F←

Pruébalo aquí!

Aceto , 27 25 bytes

Índice basado en 1.

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

Nos rEAD la entrada y Memorize ella (y directamente LOAD de nuevo), entonces negamos que ( !; conduce a un valor Truthy sólo para una cadena vacía). Si este valor es verdadero ( `), saltamos al final ( ;), donde pborramos el cero implícito.

De lo contrario, incrementamos el valor actual de la pila (inicialmente un cero), lo duplicamos y colocamos una copia en la pila a la derecha, mientras también nos movemos allí ( Id]). Luego construimos un rango decreciente ( z), unimos la pila como una cadena ( ¥) y movemos el valor (y nosotros) en la pila original nuevamente ( [). Nos LOAD el valor memorizamos anterior (la entrada) y lo comparamos con esta cadena. Si es igual, saltamos al final nuevamente, donde imprimimos el valor actual de "contador" ( =`;).

De lo contrario, se atraviesa un montón de espacio vacío hasta que la curva de Hilbert finalmente alcanza la <que coloca la IP encima I, incrementa el contador y vuelve a probar.

Apilado , 23 bytes

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

Pruébalo en línea!

Básicamente, se incrementa 0hasta que el rango desde 0el número se parece a la entrada, verificando primero la igualdad.

Jalea , 8 bytes

JVṾẎ$$Ƥi

Pruébalo en línea!