Deshacer un rango de números

34

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 , 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
Fruta Esolanging
fuente
¿Hay algún rango descendente? ¿Necesita trabajar para números negativos?
Daniel
@Daniel No. Olvidé mencionar eso; adicional.
Esolanging Fruit
44
¿Nuestros programas realmente necesitan manejar la cadena vacía? Creo que sería razonable permitirnos ignorar eso. Algunas respuestas no se benefician de esa regla en absoluto.
Sr. Xcoder
¿Puede la salida ser una representación de cadena del número, es decir, tomada como una subcadena de la cadena original?
user2390246
@ user2390246 Sí, está bien.
Esolanging Fruit

Respuestas:

11

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!

Emigna
fuente
11

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
León
fuente
8

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
Emigna
fuente
¿Estoy haciendo algo mal? Esto parece volver 0sin importar la entrada: tio.run/##MzBNTDJM/f8/3efcdi/PbLv//5UMjYxNTM3MLSwNDZQA
Shaggy
@Shaggy: Tienes que hacerlo como este o este como comillas simples cuentan como parte de la entrada.
Emigna
Ah, ¿entonces las entradas de cadena en 05AB1E deben ser citadas tres veces?
Shaggy
@ Shaggy: si desea la cadena vacía o las nuevas líneas en la entrada, sí. De lo contrario, no necesita citarlo en absoluto.
Emigna
[NÝJQ#]Nfue idea mía, pero esto es mejor porque funciona "".
Urna de pulpo mágico
7

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
Kevin Cruijssen
fuente
1
59 bytes: TIO
PunPun1000
Probablemente haya un atajo absurdo como contar el número de unidades o usar el logaritmo de la longitud para obtener la longitud de la subcadena necesaria ... Solo parece que tengo malas ideas para esto.
JollyJoker
6

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)
Fatalizar
fuente
5

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

LyricLy
fuente
5

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

Lanudo
fuente
4

Carbón , 13 bytes

I⌕E⁺ψθ⪫EκIλωθ

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)
         I      Cast to string
        κ       Outer map index
       E        Map over implicit range
      ⪫    ω    Join result
     θ          Input string
   ⁺ψ           Plus an extra character
  E             Map over each character
 ⌕          θ   Find the index of the original string
I               Cast from integer to string
                Implicit print
Neil
fuente
4

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.

Cristian Lupascu
fuente
1
37 bytes con una lista por comprensión: f s=[n|n<-[0..],(show=<<[0..n])>s]!!0.
Laikoni
1
Y sólo para mencionar, puede guardar un byte mediante el uso de la segunda guardia patrón: |m<-n+1=s!m.
Laikoni
4

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!

PunPun1000
fuente
2

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

Arnauld
fuente
1
De nuevo, ¿puedes comparar las cadenas lexicográficamente?
Esolanging Fruit
Iba a sugerir curry pero parece que ya no es un consenso :(
Shaggy
1
@Shaggy Umm, en realidad es ...
Erik the Outgolfer
1
@EriktheOutgolfer El curry estándar está bien, pero Shaggy se refería a esta forma especial de curry que requiere llamadas como f(payload_param)()o incluso f(payload_param)(some_constant). (Por cierto, no estoy seguro de que funcione en este caso en particular porque necesito ambos ry nser inicializado.)
Arnauld
2

Mathematica, 46 bytes

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

1 indexado

entrada

["12345678910"]

J42161217
fuente
2

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

Elazar
fuente
1
No necesita el último conjunto de paréntesis: .index(gets)=> .index gets. Puede usar en 4e4lugar de 8**5, aunque esto hará que funcione aún más lento. En general, está bien, y a menudo ahorra algunos bytes, usar lambdas anónimas para las respuestas de Ruby: ¡ Pruébelo en línea! (Cambié el límite a 100 para que no se agote el tiempo).
Nnnes
2

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.

xnor
fuente
¿Su "estrategia diferente" (muy inteligente, por cierto) funciona para rangos basados ​​en 0 como se requiere en la declaración del desafío? ¿Deberías cambiar la parte interna ... i*'0'in s[1:] for ...o algo así?
Luca Citi
@LucaCiti Funciona para rangos basados ​​en 1, y el desafío nos permite elegir.
xnor
Claro, tienes razón. Solo miré la descripción inicial y me perdí la parte donde permite rangos basados ​​en 1.
Luca Citi
2

R , 47 bytes

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

Pruébalo en línea!

1 indexado

usuario2390246
fuente
3
Usar en "if"lugar deifelse
Giuseppe
¡Buen punto! Pero OP ha eliminado el requisito ahora a tratar con el caso 0, por lo que puede deshacerse de ese bit del todo ...
user2390246
1
Puede tomar la entrada como un número, ya que ncharfunciona como es de esperar en los números. Sin embargo, debe manejar la impresión de su salida, ya que esto no lo haría cuando se ejecute como un programa completo.
JAD
1
n=nchar(scan());cat(which(cumsum(nchar(1:n))==n))
JAD
2

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

Adán
fuente
Oh, se me olvidó que podría ir más allá, buen trabajo.
Zacharý
{,\⍕¨⍳≢⍵}⍳⊂(11 caracteres)
ngn
@ngn tonto yo. ¡Por supuesto!
Adám
2

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.

Dom Hastings
fuente
¿Qué pasa con $i++while s/$i\B//(18 + 1 bytes)?
nwellnhof
@nwellnhof ¡Eso está mucho mejor! Creo que comencé por una ruta más compleja cuando hice la respuesta indexada en 0 en primer lugar ... ¡Gracias!
Dom Hastings
1

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
Gato de negocios
fuente
1

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.

Brad Gilbert b2gills
fuente
1

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

Sr. Xcoder
fuente
?QfqQjkUT)1también puedo hacerlo en 11, pero siento que algunos reordenamientos pueden jugar golf en un byte. ¿Algunas ideas?
Dave
Puede guardar un byte utilizando en jklugar de s`m.
1

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
geokavel
fuente
1

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
Choque suave
fuente
Lenguaje genial !!
Robert Fraser
0

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)
Luis Mendo
fuente
1
Espera, ¿el carbón vence a MATL?
Neil
0

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
auhmaan
fuente
1
i=>{int c,p=c=0;for(;p<i.Length;)p+=(c+++"").Length;return c;}62 bytes
TheLethalCoder
0

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í!

dzaima
fuente
0

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.

L3viatán
fuente
0

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.

Conor O'Brien
fuente