Es ist ziemlich einfach, bei einer bestimmten Zahl neinen Bereich von 0bis zu erstellen n-1. Tatsächlich bieten viele Sprachen diese Operation als eingebaut an.

Das folgende CJam-Programm liest eine Ganzzahl und druckt dann einen solchen Bereich aus ( Online ausprobieren ! ):

ri,

Beachten Sie, dass Zahlen ohne Trennzeichen ausgedruckt werden.

Die Herausforderung

Ihre Aufgabe ist es, diesen Prozess umzukehren. Sie sollten ein Programm schreiben, das anhand einer Zeichenfolge, die einen Bereich darstellt, die Zahl zurückgibt, mit der dieser Bereich erstellt wurde.

Spezifikationen

• Die Zahlen sind ohne Trennzeichen angegeben.
• Sie können davon ausgehen, dass die Zeichenfolge einen gültigen Bereich bildet.
• Sie können eine 0- oder 1-basierte Indizierung für Ihren Bereich verwenden.
• Sie können davon ausgehen, dass eine korrekte Ausgabe niemals 32.767 überschreitet (eine gültige Eingabe hat also niemals eine Länge von mehr als 152.725).
• Sie können davon ausgehen, dass eine korrekte Ausgabe immer positiv ist (Sie müssen also nicht mit 0 oder negativ umgehen).

Dies ist Code-Golf , also gewinnt die kürzeste konkurrierende Antwort (gemessen in Bytes).

Testfälle

0-indiziert:

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

1-indiziert:

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

Prolog (SWI) , 91 bis 80 Bytes

0-indiziert.

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

Zeilenumbrüche zur besseren Lesbarkeit hinzugefügt.

Probieren Sie es online!

Schale , 5 Bytes

LCmLN

Probieren Sie es online!

Nur Buchstaben!

Nimmt die Eingabe als String, das Ergebnis ist 1-indiziert.

Erläuterung

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

āηJsk>

Probieren Sie es online! oder als Testsuite

Erläuterung

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

-7 Bytes dank @ PunPun1000 .

Ich habe das Gefühl, dass dies verkürzt werden kann, indem nur die Länge der Eingabe überprüft wird, da davon ausgegangen werden kann, dass die Eingabe immer gültig ist. Ich finde das immer noch heraus. Kann dies nicht herausfinden, und es wird wahrscheinlich zu viele Bytes in Java kosten, um trotzdem nützlich zu sein (dasselbe gilt für die Rückgabe eines Teilstrings am Ende einer 1-indizierten Eingabe).

Erläuterung:

Probieren Sie es hier aus.

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

Probieren Sie es online!

0-indiziert.

Erläuterung

Hier übergeben wir die Eingabe über die Variable Output und greifen über die Variable Input auf das Ergebnis zu.

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

Probieren Sie es online!

Ich kann nicht glauben, dass dies so gut funktioniert hat wie es ...

Japt , 8 Bytes

Beginnend mit Funktionsmethoden in Japt.

0-indiziert. Kann Eingaben als Zeichenfolge, Ganzzahl oder Array mit 0 oder 1 Elementen annehmen.

_o ´U}a

Probier es aus

Erläuterung

Implizite Eingabe eines Strings U.

_     }a

Ruft die erste Ganzzahl ab >=0, die true zurückgibt, wenn sie eine Funktion durchläuft, die ...

o

Erzeugt ein Array von ganzen Zahlen von 0bis 1 weniger als die aktuelle ganze Zahl ...

¬

Verbindet es mit einer Schnur ...

¥U

Überprüft diese Zeichenfolge auf Gleichheit mit U.

Implizite Ausgabe der resultierenden Ganzzahl.

Alternativ 8 Bytes

ÊÇo ¬ÃbU

Probier es aus

Kohle , 13 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

          λ     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

Funktion, die nullbasierte Bereiche umkehrt.

Danke an Laikoni für das Speichern von 3 Bytes!

Probieren Sie es online aus.

Netzhaut , 30 Bytes

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

Fügt nach jeder Zahl rekursiv ein Semikolon hinzu und zählt dann die Anzahl der Semikolons

Probieren Sie es online!

JavaScript (ES6), 32-31 Byte

Dank Challenger5 1 Byte gespart

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

Testfälle

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

Eingang

[12345678910]

Ruby , 51 50 46 Bytes

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

(Dies ist mein erstes Ruby-Programm überhaupt, daher muss es einfach sein, weiter Golf zu spielen.)

-4 Bytes dank @Nnnes

Python 2 , 43 Bytes

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

Probieren Sie es online!

Python 2 , 43 Bytes

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

Probieren Sie es online!

Python , 46 Bytes

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

Probieren Sie es online!

Eine andere Strategie. Nimmt eine Anzahl von Zeichen vom Ende, die der Länge des größten Laufs von 0's in s entspricht.

Python , 46 Bytes

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

Probieren Sie es online!

Rekursive Version des oben genannten.

R , 47 Bytes

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

Probieren Sie es online!

1-indiziert

APL (Dyalog) , 17 11 Bytes

-6 Bytes dank ngn .

{,\⍕¨⍳≢⍵}⍳⊂

Probieren Sie es online!

⍳⊂ finden Sie den Index des gesamten Arguments in

{… } Das Ergebnis dieser anonymen Funktion:

 ≢ Länge des Arguments

 ⍳ ɩ ntegers bis das

 ⍕¨ jeweils formatieren (stringifizieren)

 ,\ kumulative Verkettung dieser

Perl 5 , 19 Bytes

18 Byte Code + 1 für -p.

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

Verwendet 1-basierte Indizierung. -7 Bytes dank @ nwellnhof ‚s viel Ansatz besser!

Probieren Sie es online!

Erläuterung

$\ist eine spezielle Variable, die printnach jeder Anweisung automatisch bearbeitet wird. Wenn Sie also diese Variable verwenden, um unsere Nummer zu speichern, müssen wir sie nicht aktualisieren $_(was automatisch als Teil der Funktionalität des -pFlags gedruckt wird ), um die gewünschte Ausgabe zu enthalten. Dann, während die Eingabe mit beginnt $\, entfernen Sie es und redodas Programm, das es erneut inkrementiert $\und ersetzt. Wenn die Nummer am Anfang der Zeichenfolge nicht mehr gefunden wird, sind wir fertig! Zum Schluss dekrementieren, $\damit wir die letzte Nummer im Bereich haben.

Python 2 , 46 Bytes

0-indiziert

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

Probieren Sie es online!

CJam , 16 Bytes

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

Probieren Sie es online!

Alternative 16 Bytes

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

Probieren Sie es online!

CJam , 13 Bytes

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

So viele Kommas ...

Probieren Sie es online!

Erläuterung

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

Probier es aus

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

Probier es aus

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

Probier es aus

Erweitert:

{  # 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...*eine unendliche Folge von Werten erzeugt '', 0, 1, 2, 3...

[\~] '',0...* Erzeugt eine unendliche Folge aller möglichen Eingaben

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

Beachten Sie, dass dieser Code niemals beendet wird, wenn Sie eine ungültige Eingabe machen.

Pyth , 11 10 Bytes

1-indiziert.

fqQ|jkSTk0

Probieren Sie es hier aus

Wenn die leere Zeichenfolge ignoriert werden konnte, kann dies auf 6 Byte verkürzt werden :

fqQjkS

-1 Byte dank @Mnemonic

CJam, 14 12 11 Bytes

q,_){,s,}%#

Probieren Sie es 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}

Gleicher Algorithmus wie diese Java-Antwort , außer dass (ab) einige syntaktische Besonderheiten von Dyvil verwendet.

Erläuterung:

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

• Gespeicherte 4Bytes mithilfe eines geschweiften Zugriffsausdrucks anstelle einer Variablen für den Akkumulator

MATL , 14 Bytes

`@q:VXzGX=~}@q

1-indiziert.

Probieren Sie es online!

Erläuterung

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

Daten

• Eingabe String i Das zu entschlüsselnde Int-Array
• Ausgabe Int32 Die Nummer, mit der das Array erstellt wird

Golf gespielt

(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 lesbar

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

Vollständiger Code

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

Releases

• v1.0 - 72 bytes- Anfangslösung.

Anmerkungen

• Keiner

SOGL V0.12 , 11 10 9 Bytes

1-indiziert.

I∫HΔ∑=?f←

Probieren Sie es hier aus!

Erläuterung:

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

..oder 7 Bytes ohne den leeren Fall

∫Δ∑=?F←

Probieren Sie es hier aus!

Aceto , 27 25 Bytes

1-basierter Index.

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

Wir rlesen den Input und Memorisieren ihn (und Lladen ihn direkt wieder), dann negieren wir ihn ( !was nur für einen leeren String zu einem Wahrheitswert führt). Wenn dieser Wert wahr ist ( `), springen wir zum Ende ( ;), wo wir pdie implizite Null eingeben .

Andernfalls erhöhen wir den aktuellen Stapelwert (anfangs eine Null), duplizieren ihn und legen eine Kopie auf den Stapel nach rechts, während wir uns ebenfalls dorthin bewegen ( Id]). Dann konstruieren wir einen abnehmenden Bereich ( z), verbinden den Stapel als String ( ¥) und verschieben den Wert (und uns) wieder auf den ursprünglichen Stapel ( [). Wir Lladen den zuvor gespeicherten Wert (die Eingabe) und vergleichen ihn mit dieser Zeichenfolge. Wenn gleich, springen wir wieder zum Ende, wo wir den aktuellen "Zähler" -Wert ( =`;) ausgeben .

Andernfalls wird viel leerer Raum durchlaufen, bis die Hilbert-Kurve schließlich den <Wert erreicht, mit dem die IP Iwieder oben liegt, der Zähler erhöht und erneut getestet wird.

Gestapelt , 23 Bytes

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

Probieren Sie es online!

Grundsätzlich wird 0solange inkrementiert, bis der Bereich von 0bis zur Zahl der Eingabe entspricht, wobei zuerst auf Gleichheit geprüft wird.

Gelee , 8 Bytes

JVṾẎ$$Ƥi

Probieren Sie es online!