È abbastanza semplice, dato un numero n, creare un intervallo da 0a n-1. In effetti, molte lingue forniscono questa operazione come integrata.

Il seguente programma CJam legge un numero intero e quindi stampa tale intervallo ( Provalo online! ):

ri,

Si noti che stampa i numeri senza un separatore.

La sfida

Il tuo compito è invertire questo processo. Dovresti scrivere un programma che, data una stringa che rappresenta un intervallo, restituisce il numero usato per produrre quell'intervallo.

specificazioni

• I numeri sono indicati senza alcun separatore.
• Si può presumere che la stringa formi un intervallo valido.
• È possibile utilizzare l'indicizzazione basata su 0 o 1 per l'intervallo.
• Si può presumere che un output corretto non supererà mai 32.767 (quindi un input valido non avrà mai una lunghezza superiore a 152.725).
• Si può presumere che un output corretto sarà sempre positivo (quindi non è necessario gestire 0 o negativo).

Si tratta di code-golf , quindi vince la risposta competitiva più breve (misurata in byte).

Casi test

0-indicizzati:

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

1-indicizzati:

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

Prolog (SWI) , 91 80 byte

0-indicizzati.

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

Newline aggiunti per la leggibilità.

Provalo online!

Buccia , 5 byte

LCmLN

Provalo online!

Solo lettere!

Accetta l'input come stringa, il risultato è 1 indicizzato.

Spiegazione

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

āηJsk>

Provalo online! o come una suite di test

Spiegazione

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

0-indicizzato

-7 byte grazie a @ PunPun1000 .

Ho la sensazione che questo possa essere abbreviato controllando la lunghezza dell'input in qualche modo, poiché possiamo supporre che l'input sia sempre valido. Lo sto ancora capendo.Incapace di capirlo, e probabilmente costerà troppi byte in Java per essere comunque utile (lo stesso vale per la restituzione di una sottostringa della fine di un input con 1 indice).

Spiegazione:

Provalo qui.

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,Ẹ

Provalo online!

0-indicizzati.

Spiegazione

Qui passiamo l'input attraverso la variabile Output e accediamo al risultato attraverso la variabile 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 byte

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

Provalo online!

Non riesco a credere che abbia funzionato bene come ...

Japt , 8 byte

Iniziare a familiarizzare con i metodi di funzione in Japt.

0-indicizzati. Può accettare input come una stringa, un numero intero o un array contenente 0 o 1 elementi.

_o ´U}a

Provalo

Spiegazione

Immissione implicita della stringa U.

_     }a

Ottieni il primo numero intero >=0che restituisce true quando viene passato attraverso una funzione che ...

o

Genera un array di numeri interi da 01 a meno dell'intero corrente ...

¬

Unisce a una stringa ...

¥U

Controlla la stringa per l'uguaglianza con U.

Output implicito dell'intero risultante.

Alternativa, 8 byte

ÊÇo ¬ÃbU

Provalo

Carbone , 13 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

          λ     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

Funzione che inverte gli intervalli in base zero.

Grazie a Laikoni per aver salvato 3 byte!

Provalo online.

Retina , 30 byte

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

Aggiunge ricorsivamente un punto e virgola dopo ogni numero, quindi conta il numero di punti e virgola

Provalo online!

JavaScript (ES6), 32 31 byte

Salvato 1 byte grazie a Challenger5

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

Casi test

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 byte

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

1-indicizzato

ingresso

[ "12345678910"]

Rubino , 51 50 46 byte

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

(Questo è il mio primo programma Ruby in assoluto, quindi deve essere facile giocarlo ulteriormente)

-4 byte grazie a @Nnnes

Python 2 , 43 byte

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

Provalo online!

Python 2 , 43 byte

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

Provalo online!

Python , 46 byte

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

Provalo online!

Una strategia diversa. Prende un numero di caratteri dalla fine pari alla lunghezza della corsa più grande di 0's in s.

Python , 46 byte

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

Provalo online!

Versione ricorsiva di quanto sopra.

R , 47 byte

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

Provalo online!

1-indicizzato

APL (Dyalog) , 17 11 byte

-6 byte grazie a ngn .

{,\⍕¨⍳≢⍵}⍳⊂

Provalo online!

⍳⊂ trova ɩ ndex dell'intero argomento in

{... } il risultato di questa funzione anonima:

 ≢ lunghezza dell'argomento

 ⍳ ɩ ntegers fino a quel

 ⍕¨ formato (stringify) ciascuno

 ,\ concatenazione cumulativa di quelli

Perl 5 , 19 byte

18 byte codice + 1 per -p.

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

Utilizza l'indicizzazione basata su 1. -7 byte grazie a @ nwellnhof 's molto meglio approccio!

Provalo online!

Spiegazione

$\è una variabile speciale che viene printeditata automaticamente dopo ogni istruzione, quindi usando quello per memorizzare il nostro numero non abbiamo bisogno di aggiornare $_(che viene automaticamente stampato come parte della funzionalità del -pflag) per contenere l'output desiderato. Quindi, mentre l'ingresso inizia con $\, rimuoverlo e redoil programma, che di nuovo aumenta $\e lo sostituisce. Quando non trova più il numero all'inizio della stringa, abbiamo finito! Infine, diminuisci in $\modo da avere l'ultimo numero nell'intervallo.

Python 2 , 46 byte

0-indicizzato

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

Provalo online!

CJam , 16 byte

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

Provalo online!

16 byte alternativi

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

Provalo online!

CJam , 13 byte

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

Così tante virgole ...

Provalo online!

Spiegazione

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

Provalo

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

Provalo

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

Provalo

Allargato:

{  # 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 sequenza infinita di valori '', 0, 1, 2, 3...

[\~] '',0...* produce una sequenza infinita di tutti i possibili input

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

Nota che questo codice non si fermerà mai se gli dai un input non valido.

Pyth , 11 10 byte

1-indicizzati.

fqQ|jkSTk0

Provalo qui

Se è possibile ignorare la stringa vuota, è possibile accorciarla a 6 byte :

fqQjkS

-1 byte grazie a @Mnemonic

CJam, 14 12 11 byte

q,_){,s,}%#

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

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

Stesso algoritmo di questa risposta Java , tranne per il fatto che (ab) utilizza alcune delle specialità sintattiche di Dyvil.

Spiegazione:

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

• 4Byte salvati utilizzando un'espressione di accesso parentesi anziché una variabile per l'accumulatore

MATL , 14 byte

`@q:VXzGX=~}@q

1-indicizzati.

Provalo online!

Spiegazione

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

Dati

• Input String i La matrice int da decifrare
• Output Int32 Il numero utilizzato per creare l'array

golfed

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

Leggibile non golfato

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

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

Uscite

• v1.0 - 72 bytes- Soluzione iniziale.

Gli appunti

• Nessuna

SOGL V0.12 , 11 10 9 byte

1-indicizzati.

I∫HΔ∑=?f←

Provalo qui!

Spiegazione:

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 byte senza il caso vuoto

∫Δ∑=?F←

Provalo qui!

Aceto , 27 25 byte

1 indice basato.

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

Abbiamo read l'ingresso e Memorize esso (e direttamente LOAD nuovamente), allora neghiamo esso ( !, portando ad un valore truthy solo per una stringa vuota). Se questo valore è true ( `), passiamo alla fine ( ;), dove pstampiamo lo zero implicito.

Altrimenti, incrementiamo il valore dello stack corrente (inizialmente uno zero), lo dupliciamo e mettiamo una copia nello stack a destra, spostandoci anche lì ( Id]). Costruiamo quindi un intervallo decrescente ( z), uniamo lo stack come stringa ( ¥) e spostiamo nuovamente il valore (e noi) sullo stack originale ( [). NoiL il valore che abbiamo memorizzato in precedenza (l'input) e confrontarlo con questa stringa. Se uguale, saltiamo di nuovo alla fine, dove stampiamo l'attuale valore "contatore" (=`; ).

Altrimenti, viene attraversato un sacco di spazio vuoto fino a quando la curva di Hilbert non raggiunge il valore <che pone Inuovamente l'IP , incrementando il contatore e testando di nuovo.

Impilato , 23 byte

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

Provalo online!

Fondamentalmente, aumenta 0fino a quando l'intervallo da 0al numero appare come l'input, verificando prima l'uguaglianza.

Gelatina , 8 byte

JVṾẎ$$Ƥi

Provalo online!