Il est assez simple de ncréer, à partir 0d’ un nombre , une plage allant de à n-1. En fait, de nombreuses langues fournissent cette opération de manière intégrée.

Le programme CJam suivant lit un entier, puis imprime une telle plage ( essayez-le en ligne! ):

ri,

Notez qu'il imprime des nombres sans séparateur.

Le défi

Votre tâche consiste à inverser ce processus. Vous devriez écrire un programme qui, avec une chaîne représentant une plage, renvoie le nombre utilisé pour produire cette plage.

Caractéristiques

• Les nombres sont donnés sans séparateur.
• Vous pouvez supposer que la chaîne forme une plage valide.
• Vous pouvez utiliser l'indexation 0 ou 1 pour votre plage.
• Vous pouvez supposer qu'une sortie correcte ne dépassera jamais 32 767 (une entrée valide n'aura jamais une longueur supérieure à 152 725).
• Vous pouvez supposer qu'une sortie correcte sera toujours positive (vous n'aurez donc pas à gérer 0 ou négatif).

C'est du code-golf , donc la réponse concurrente la plus courte (mesurée en octets) est gagnante.

Cas de test

0 indexé:

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

1 indexé:

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

Prolog (SWI) , 91 à 80 octets

0 indexé.

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

Nouvelles lignes ajoutées pour plus de lisibilité.

Essayez-le en ligne!

Husk , 5 octets

LCmLN

Essayez-le en ligne!

Seulement des lettres!

Prend l'entrée en tant que chaîne, le résultat est 1-indexé.

Explication

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 octets

1 indexé.

āηJsk>

Essayez-le en ligne! ou en tant que suite de tests

Explication

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

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

0 indexé

-7 octets grâce à @ PunPun1000 .

J'ai l'impression que cela peut être raccourci en ne vérifiant que la longueur de l'entrée, puisque nous pouvons supposer que l'entrée est toujours valide. Toujours en train de comprendre cela. Impossible de comprendre cela, et cela coûtera probablement trop d'octets en Java pour être utile (de même pour le retour d'une sous-chaîne à la fin d'une entrée à 1 index).

Explication:

Essayez ici.

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 octets

⟦kṫᵐc,Ẹ

Essayez-le en ligne!

0 indexé.

Explication

Ici, nous passons l'entrée par la variable de sortie et accédons au résultat par la variable d'entrée.

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

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

Essayez-le en ligne!

Je ne peux pas croire que cela a fonctionné aussi bien que cela a été ...

Japt , 8 octets

Commencer à se familiariser avec les méthodes de fonction dans Japt.

0 indexé. Peut prendre les entrées sous forme de chaîne, un entier ou un tableau contenant 0 ou 1 élément.

_o ´U}a

Essaye-le

Explication

Entrée implicite de chaîne U.

_     }a

Récupère le premier entier >=0qui retourne vrai lorsqu'il est passé par une fonction qui ...

o

Génère un tableau d'entiers de 01 à 1 inférieur à l'entier actuel ...

¬

Se joint à une chaîne ...

¥U

Vérifie l'égalité de cette chaîne avec U.

Sortie implicite de l'entier résultant.

Alternative, 8 octets

ÊÇo ¬ÃbU

Essaye-le

Charbon de bois , 13 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

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

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

Fonction qui inverse les plages basées sur zéro.

Merci à Laikoni d'avoir économisé 3 octets!

Essayez-le en ligne.

Rétine , 30 octets

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

Ajoute récursivement un point-virgule après chaque nombre, puis compte le nombre de points-virgules

Essayez-le en ligne!

JavaScript (ES6), 32 31 octets

Enregistré 1 octet grâce à Challenger5

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

Cas de 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 octets

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

1 indexé

contribution

["12345678910"]

Ruby , 51 50 46 octets

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

(Ceci est mon premier programme Ruby, il doit donc être facile de jouer au golf plus loin)

-4 octets grâce à @Nnnes

Python 2 , 43 octets

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

Essayez-le en ligne!

Python 2 , 43 octets

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

Essayez-le en ligne!

Python , 46 octets

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

Essayez-le en ligne!

Une stratégie différente Prend un nombre de caractères à partir de la fin égal à la longueur du plus grand nombre de 0's dans s.

Python , 46 octets

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

Essayez-le en ligne!

Version récursive de ce qui précède.

R , 47 octets

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

Essayez-le en ligne!

1 indexé

APL (Dyalog) , 17 à 11 octets

-6 octets grâce à ngn .

{,\⍕¨⍳≢⍵}⍳⊂

Essayez-le en ligne!

⍳⊂ trouver le ɩ ndex de l'argument entier dans

{… } Le résultat de cette fonction anonyme:

 ≢ longueur de l'argument

 ⍳ ɩ ntegers jusqu'à ce

 ⍕¨ format (stringify) chaque

 ,\ concaténation cumulative de ceux

Perl 5 , 19 octets

Code de 18 octets + 1 pour -p.

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

Utilise l'indexation basée sur 1. -7 octets grâce à @ nwellnhof « s beaucoup meilleure approche!

Essayez-le en ligne!

Explication

$\est une variable spéciale qui est printédité automatiquement après chaque instruction. Ainsi, en utilisant celle-ci pour stocker notre numéro, nous n'avons pas besoin de la mettre à jour $_(elle est automatiquement imprimée dans le cadre de la fonctionnalité de l' -pindicateur) pour contenir la sortie souhaitée. Ensuite, pendant que l'entrée commence par $\, supprimez-la et redole programme, qui l'incrémente $\et la remplace à nouveau. Quand il ne trouve plus le numéro au début de la chaîne, c'est fini! Enfin, décrémentez $\nous avons le dernier numéro de la plage.

Python 2 , 46 octets

0 indexé

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

Essayez-le en ligne!

CJam , 16 octets

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

Essayez-le en ligne!

Alternative 16 octets

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

Essayez-le en ligne!

CJam , 13 octets

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

Tant de virgules ...

Essayez-le en ligne!

Explication

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 octets

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

Essaye-le

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

Essaye-le

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

Essaye-le

Étendu:

{  # 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...*produit une séquence infinie de valeurs '', 0, 1, 2, 3...

[\~] '',0...* produit une séquence infinie de toutes les entrées possibles

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

Notez que ce code ne s’arrêtera jamais si vous lui donnez une entrée invalide.

Pyth , 11 à 10 octets

1 indexé.

fqQ|jkSTk0

Essayez-le ici

Si la chaîne vide peut être ignorée, cela peut être réduit à 6 octets :

fqQjkS

-1 octet grâce à @Mnemonic

CJam, 14 12 11 octets

q,_){,s,}%#

Essayez-le en ligne

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 octets

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

Même algorithme que cette réponse Java , sauf qu'il (ab) utilise certaines des spécialités syntaxiques de Dyvil.

Explication:

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

• Octets sauvegardés 4en utilisant une expression d'accès d'accolade au lieu d'une variable pour l'accumulateur

MATL , 14 octets

`@q:VXzGX=~}@q

1 indexé.

Essayez-le en ligne!

Explication

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

Les données

• Input String i Le tableau int à déchiffrer
• Sortie Int32 Le nombre utilisé pour faire le tableau

Golfé

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

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

Code complet

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

Communiqués

• v1.0 - 72 bytes- Solution initiale.

Remarques

• Aucun

SOGL V0.12 , 11 10 9 octets

1 indexé.

I∫HΔ∑=?f←

Essayez-le ici!

Explication:

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 octets sans la casse vide

∫Δ∑=?F←

Essayez-le ici!

Aceto , 27 25 octets

Indice basé sur 1.

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

Nous rlisons l'entrée et l' Memorisons (et l'y Lretournons directement ), puis nous le nions ( !; conduisant à une valeur de vérité uniquement pour une chaîne vide). Si cette valeur est vérité ( `), nous sautons à la fin ( ;), où nous pimprimons le zéro implicite.

Sinon, nous incrémentons la valeur actuelle de la pile (initialement un zéro), la dupliquons et plaçons une copie sur la pile à droite, tout en y déplaçant également ( Id]). Nous construisons ensuite une plage décroissante ( z), joignons la pile en tant que chaîne ( ¥) et déplaçons à nouveau la valeur (et nous) sur la pile d'origine ( [). Nous Lexaminons la valeur que nous avons mémorisée précédemment (l'entrée) et la comparons avec cette chaîne. Si égal, nous sautons à la fin, où nous imprimons la valeur actuelle du "compteur" ( =`;).

Sinon, beaucoup d’espace vide est parcouru jusqu’à ce que la courbe de Hilbert atteigne <l’adresse IP I, ce qui augmente l’ adresse IP , incrémente le compteur et effectue un nouveau test.

Empilés , 23 octets

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

Essayez-le en ligne!

Fondamentalement, s’incrémente 0jusqu’à ce que la plage allant de 0à soit identique à l’entrée, vérifiant d’abord l’égalité.

Gelée , 8 octets

JVṾẎ$$Ƥi

Essayez-le en ligne!