Nous avons beaucoup d'axes horizontaux pour les chiffres, mais je pense honnêtement qu'ils sont un peu ennuyeux. Votre tâche aujourd'hui est de me construire une portion d'un axe diagonal entre deux entiers non négatifs distincts donnés en entrée.

Comment construire un axe diagonal?

• Prenons un exemple, avec l'entrée 0, 5. Notre axe devrait ressembler à ceci:

  0
   1
    2
     3
      4
       5
  

• Cependant, notre axe devrait bien paraître pour les nombres qui ont plus de chiffres aussi! Si l'entrée est, par exemple 0, 14, le nouvel axe doit être:

  0
   1
    2
     3
      4
       5
        6
         7
          8
           9
            dix
              11
                12
                  13
                    14
  

• L'idée est que le premier chiffre du nombre suivant sur l'axe doit toujours être placé exactement après le dernier chiffre du nombre précédent. Pour mieux comprendre l'idée, voici un autre exemple avec 997, 1004:

  997
     998
        999
           1000
               1001
                   1002
                       1003
                           1004
  

Règles

• Vous pouvez supposer que l'entrée est dans l'ordre croissant ou décroissant (vous pouvez choisir entre 5,3et 3,5).

• Vous pouvez également supposer que la différence entre les deux entiers est inférieure à 100.

• Vous pouvez avoir une nouvelle ligne de début ou un espace de début cohérent (sur chaque ligne). Les espaces de fin / les nouvelles lignes conviennent également.

• Les failles par défaut sont interdites.

• Vous pouvez prendre des entrées et fournir des sorties par n'importe quel moyen standard .

• C'est le code-golf , donc le code le plus court en octets dans toutes les langues gagne!

Autres cas de test

• 1, 10:

  1
   2
    3
     4
      5
       6
        7
         8
          9
           dix
  

• 95, 103:

  95
    96
      97
        98
          99
            100
               101
                  102
                     103
  

• 999999, 1000009:

  999999
        1000000
               1000001
                      1000002
                             1000003
                                    1000004
                                           1000005
                                                  1000006
                                                         1000007
                                                                1000008
                                                                       1000009
  

05AB1E , 8 7 6 octets

Merci à Magic Octopus Urn pour avoir sauvé un octet!

Cela fonctionne en quelque sorte, mais honnêtement, je ne sais pas pourquoi.

Code

Ÿvy.O=

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Explication

Ÿ          # Create the range [a, .., b] from the input array
 vy        # For each element
   .O      #   Push the connected overlapped version of that string using the
                 previous version of that string. The previous version initially
                 is the input repeated again. Somehow, when the input array is
                 repeated again, this command sees it as 1 character, which gives
                 the leading space before each line outputted. After the first
                 iteration, it reuses on what is left on the stack from the
                 previous iteration and basically attaches (or overlaps) itself 
                 onto the previous string, whereas the previous string is replaced 
                 by spaces and merged into the initial string. The previous string
                 is then discarded. We do not have to worry about numbers overlapping 
                 other numbers, since the incremented version of a number never
                 overlaps entirely on the previous number. An example of 123 and 456:

                 123
                    456

                 Which leaves us "   456" on the stack.
     =     #   Print with a newline without popping

Python 2 , 43 octets

lambda a,b:'\v'.join(map(str,range(a,b+1)))

Utilise une languette verticale pour créer un effet d'échelle. La façon dont le \vrendu est rendu dépend de la console, il peut donc ne pas fonctionner partout (comme TIO).

Fusain , 9 8 octets

Ｆ…·ＮＮ⁺¶ι

Essayez-le en ligne!

Le lien est vers la version détaillée du code. Saisie par ordre croissant.

• 1 octet enregistré grâce à ASCII uniquement!

R, 70 69 61 octets

function(a,b)for(i in a:b){cat(rep('',F),i,'
');F=F+nchar(i)}

Fonction qui prend la variable de début et de fin comme arguments. Boucle sur la séquence et imprime chaque élément, ajouté avec suffisamment d'espace. Fcommence au fur FALSE=0et à chaque itération, la quantité de caractères pour cette valeur y est ajoutée. Fdécide du nombre d'espaces imprimés.

Essayez-le en ligne!

-8 octets grâce à @Giuseppe

C #, 90 89 85 octets

s=>e=>{var r="";for(int g=0;e>s;g+=(s+++"").Length)r+="".PadLeft(g)+s+"\n";return r;}

1 octet enregistré grâce à @LiefdeWen.
4 octets enregistrés grâce à @auhmaan.

Essayez-le en ligne!

Version complète / formatée:

namespace System
{
    class P
    {
        static void Main()
        {
            Func<int, Func<int, string>> f = s => e =>
            {
                var r = "";
                for (int g = 0; e > s; g += (s++ + "").Length)
                    r += "".PadLeft(g) + s + "\n";

                return r;
            };

            Console.WriteLine(f(0)(5));
            Console.WriteLine(f(0)(14));
            Console.WriteLine(f(997)(1004));
            Console.WriteLine(f(1)(10));
            Console.WriteLine(f(95)(103));
            Console.WriteLine(f(999999)(1000009));

            Console.ReadLine();
        }
    }
}

Python 2 , 58 54 octets

def f(a,b,s=''):print s;b<a or f(a+1,b,' '*len(s)+`a`)

Essayez-le en ligne!

Mathematica, 59, octets

Grid[(DiagonalMatrix@Range[1+##]/. 0->""+1)-1,Spacings->0]&

contribution

[10,15]

-3 octets @JungHwanMin
problème avec 0 fixe (voir les commentaires pour plus de détails)
merci à @ngenisis

Gelée , 9 octets

rD⁶ṁ$;¥\Y

Essayez-le en ligne!

Mathematica, 48 octets

Rotate[""<>Table[ToString@i<>" ",{i,##}],-Pi/4]&

comme il y a tellement de réponses, je pensais que celle-ci devrait être incluse

contribution

[0,10]

sortie

C, 166 134 95 82 octets

Nouvelle réponse

Juste comme une fonction et non comme un programme entier.

f(a,b){int s=0,i;while(a<=b){i=s;while(i--)printf(" ");s+=printf("%i\n",a++)-1;}}

Merci à Falken d'avoir aidé à éliminer 13 octets (et à corriger un problème)!

Merci à Steph Hen d'avoir aidé à éliminer 12 octets!

Merci à Zacharý pour son aide à supprimer 1 octet!

Anciennes réponses

Débarrassé de int avant main et changé const char * v [] en char ** v et débarrassé de return 0;

main(int c,char**v){int s=0;for(int a=atoi(v[1]);a<=atoi(v[2]);a++){for(int i=0;i<s;i++)printf(" ");printf("%i\n",a);s+=log10(a)+1;}}


int main(int c,const char*v[]){int s=0;for(int a=atoi(v[1]);a<=atoi(v[2]);a++){for(int i=0;i<s;i++)printf(" ");printf("%i\n",a);s+=log10(a)+1;}return 0;}

C'est la première fois que je joue au golf et je voulais essayer quelque chose en C. Je ne sais pas si j'ai formaté cela correctement, mais j'ai eu du plaisir à le faire!

int main(int c, const char * v[]) {
    int s = 0;
    for(int a=atoi(v[1]); a<=atoi(v[2]); a++) {
        for(int i=0; i<s; i++) printf(" ");
        printf("%i\n",a);
        s += log10(a)+1;
    }
    return 0;
}

Explication

int s = 0; // Number of spaces for each line

for(int a=atoi(argv[1]); a<=atoi(argv[2]); a++) { // Loop thru numbers

for(int i=0; i<s; i++) printf(" "); // Add leading spaces

printf("%i\n",a); // Print number

s += log10(a)+1; // Update leading spaces

Usage

C ++, 167 165 octets

-2 octets grâce à Zacharý

#include<string>
#define S std::string
S d(int l,int h){S r;for(int m=0,i=l,j;i<=h;){for(j=0;j<m;++j)r+=32;S t=std::to_string(i++);r+=t;r+=10;m+=t.size();}return r;}

APL (Dyalog) , 25 24 octets

-1 merci à Zacharý .

Suppose ⎕IO←0que le comptage est basé sur zéro. Prend la borne inférieure comme argument de gauche et la borne supérieure comme argument de droite.

{↑⍵↑⍨¨-+\≢¨⍵}(⍕¨⊣+∘⍳1--)

Essayez-le en ligne!

(… ) Appliquer la fonction tacite suivante entre les arguments:

 - soustraire la partie supérieure inférieure de la limite supérieure

 1- soustrayez cela d'un (c.-à-d. 1 + ∆)

 ⊣+∘⍳ borne inférieure gauche plus les entiers 0 à travers cette

 ⍕¨ formater (stringify) chacun

{… } Appliquer l'anonymat suivant à ce sujet (représenté par ⍵):

 ≢¨ longueur de chacun (nombre)

 +\ somme cumulée

 - nier

 ⍵↑⍨¨ pour chaque nombre stratifié, prenez autant de caractères de la fin (blocs avec des espaces)

 ↑ mélanger la liste des chaînes dans une matrice de caractères

Rétine , 81 78 octets

.+
$*
+`\b(1+)¶11\1
$1¶1$&
1+
$.& $.&
 (.+)
$.1$* 
+1`( *)(.+?)( +)¶
$1$2¶$1$3

Essayez-le en ligne! Prend l'entrée comme une liste séparée par des sauts de ligne de deux entiers. Edit: sauvé 3 octets en volant le code d'extension de plage de ma réponse à Partageons-nous le cluster principal? Explication:

.+
$*

Convertissez les deux entrées en unaire.

+`\b(1+)¶11\1
$1¶1$&

Alors que les deux derniers éléments (a, b) de la liste diffèrent de plus de 1, remplacez-les par (a, a + 1, b). Cela étend la liste d'un tuple à une plage.

1+
$.& $.&

Convertissez en décimal en double.

 (.+)
$.1$* 

Convertissez la copie en double en espaces.

+1`( *)(.+?)( +)¶
$1$2¶$1$3

Additionnez cumulativement les espaces de chaque ligne à la suivante.

Pyth , 14 13 octets

V}FQ
=k+*dlkN

Essayez-le en ligne!

LOGO , 53 octets

[for[i ? ?2][repeat ycor[type "\ ]pr :i fd count :i]]

Il n'y a pas de "Essayez-le en ligne!" lien car tous les interpréteurs de LOGO en ligne ne prennent pas en charge la liste de modèles.

Il s'agit d'une liste de modèles (équivalent de la fonction lambda dans d'autres langues).

Usage:

apply [for[i ? ?2][repeat ycor[type "\ ]pr :i fd count :i]] [997 1004]

( applyappelle la fonction)

imprimera

997
   998
      999
         1000
             1001
                 1002
                     1003
                         1004

Remarque:

Cela utilise la tortue ycor(coordonnée Y) pour stocker le nombre d'espaces nécessaires pour taper, donc:

• La tortue doit être mise à la maison dans sa position et sa direction par défaut (vers le haut) avant chaque invocation.
• windowdoit être exécuté s'il ycordevient trop gros pour que la tortue quitte l'écran. Description de la windowcommande if the turtle is asked to move past the boundary of the graphics window, it will move off screen.:, contrairement au paramètre par défaut wrap, quiif the turtle is asked to move past the boundary of the FMSLogo screen window, it will "wrap around" and reappear at the opposite edge of the window.

Explication:

for[i ? ?2]        Loop variable i in range [?, ?2], which is 2 input values
repeat ycor        That number of times
type "\            space character need to be escaped to be typed out.
pr :i              print the value of :i with a newline
fd count :i        increase turtle's y-coordinate by the length of the word :i. (Numbers in LOGO are stored as words)

05AB1E , 8 octets

Ÿʒ¾ú=þv¼

Essayez-le en ligne!

-2 merci à Adnan .

JavaScript (ES8), 69 67 62 octets

Prend les entrées sous forme d'entiers, dans l'ordre croissant, en utilisant la syntaxe de curry. Renvoie un tableau de chaînes.

x=>y=>[...Array(++y-x)].map(_=>s="".padEnd(s.length)+x++,s="")

Essayez-le

o.innerText=(f=

x=>y=>[...Array(++y-x)].map(_=>s="".padEnd(s.length)+x++,s="")

)(i.value=93)(j.value=105).join`\n`
oninput=_=>o.innerText=f(Math.min(i.value,j.value))(Math.max(i.value,j.value)).join`\n`

label,input{font-family:sans-serif}input{margin:0 5px 0 0;width:100px;}

<label for=i>x: </label><input id=i type=number><label for=j>y: </label><input id=j type=number><pre id=o>

Japt , 12 octets

òV
£¯Y ¬ç +X

Prend l'entrée dans l'un ou l'autre ordre et renvoie toujours les nombres dans l'ordre croissant, sous la forme d'un tableau de lignes.

Essayez-le en ligne! avec le -Rdrapeau pour rejoindre le tableau avec des sauts de ligne.

Explication

Saisie implicite de Uet V.

òV
£

Créez une plage inclusive [U, V]et mappez chaque valeur sur ...

¯Y ¬ç

Les valeurs avant le courant ( ¯Y), jointes à une chaîne ( ¬) et remplies d'espaces ( ç).

+X

Plus le numéro actuel. Le tableau résultant est implicitement sorti.

Python 2 , 65 63 62 61 octets

-2 octets Merci à @Mr. Xcoder: execn'a pas besoin d'accolades

-1 bye merci à @ Zacharý: print s*' 'asprint' '*s

def f(m,n,s=0):exec(n-m+1)*"print' '*s+`m`;s+=len(`m`);m+=1;"

Essayez-le en ligne!

JavaScript, 57 octets

f=(x,y,s='')=>y>=x?s+`
`+f(x+1,y,s.replace(/./g,' ')+x):s

Python 2, 60 59 octets

-1 octet merci à Mr.Xcoder pour avoir défini mon s = 0 comme variable optionnelle dans ma fonction.

def f(l,u,s=0):
 while l<=u:print' '*s+`l`;s+=len(`l`);l+=1

Essayez-le en ligne!

Je pense qu'il est possible de transférer cela dans une version lambda, mais je ne sais pas comment. Je pense également qu'il existe une sorte de correspondance entre les espaces et la longueur du nombre actuel, mais je ne l'ai pas encore compris. Je pense donc qu'il y a encore place à amélioration.

Ce que j'ai fait était de créer une plage de la limite inférieure là la limite supérieure en uimprimant chaque ligne avec un espace multiplié par un nombre s. J'augmente le multiplicateur avec la longueur du nombre actuel.

Python 2, 78 77 79 octets

def f(a,b):
 for i in range(a,b+1):print sum(len(`j`)for j in range(i))*' '+`i`

Essayez-le en ligne!

f(A, B) imprimera la partie de l'axe entre A et B inclus.

Première fois que je réponds à un défi!

Utilise et abuse des astuces de Python 2 pour compter le nombre d'espaces qu'il doit ajouter avant le nombre.

-1 octet grâce à Mr.Xcoder

+2 car j'ai oublié un +1

C (gcc) , 41 38 octets

-3 octets grâce à ASCII uniquement

t(x,v){while(x<=v)printf("%d\v",x++);}

Fonctionne sur RedHat6, accessible via PuTTY

Essayez-le en ligne!

V , 16 octets

ÀñÙywÒ $pça/jd

Essayez-le en ligne!

Ce serait beaucoup plus facile si je pouvais prendre start end - startmais je pense que cela change un peu trop le défi.

Cela prend le numéro de début comme entrée dans le tampon et le numéro de fin comme argument. Il crée en fait l'échelle de startà start + endpuis supprime tout après le numéro de fin.

MATL , 11 octets

vii&:"t~@Vh

Essayez-le en ligne!

Explication

Cela fonctionne en générant une chaîne pour chaque numéro et en la concaténant avec une copie à négation logique de la chaîne précédente. Ainsi, char 0 est ajouté 0 autant de fois que la longueur de la chaîne précédente. Le caractère 0 est affiché comme un espace et chaque chaîne est affichée sur une ligne différente

v       % Concatenate stack (which is empty): pushes []
ii      % Input two numbers
&:      % Range between the two numbers
"       % For each
  t     %   Duplicate
  ~     %   Logical negation. This gives a vector of zeros
  @     %   Push current number
  V     %   Convert to string
  h     %   Concatenate with the vector of zeros, which gets automatically 
        %   converted into chars.
        % End (implicit). Display stack (implicit), each string on a diferent
        % line, char 0 shown as space

Swift 4 , 115 octets

Je pense que personne n'aurait publié une solution Swift de toute façon ...

func f(l:Int,b:Int){for i in l...b{print(String(repeating:" ",count:(l..<i).map{String($0).count}.reduce(0,+)),i)}}

Essayez-le en ligne!

Perl, 19 octets

Remarque: \x0best compté comme un octet.

Avec d'autres, je pensais que l'utilisation des mouvements du curseur serait l'itinéraire le plus court, cela signifie que cela ne fonctionne pas sur TIO:

print"$_\x0b"for<>..<>

Usage

perl -e 'print"$_\x0b"for<>..<>' <<< '5
10'
5
 6
  7
   8
    9
     10

Japt , 10 9 octets

òV åÈç +Y

Testez-le en ligne! Renvoie un tableau de lignes; -Rdrapeau inclus pour rejoindre les nouvelles lignes pour une visualisation plus facile.

Explication

 òV åÈ   ç +Y
UòV åXY{Xç +Y}   Ungolfed
                 Implicit: U, V = inputs, P = empty string
UòV              Create the range [U, U+1, ..., V-1, V].
    åXY{     }   Cumulative reduce: Map each previous result X and current item Y to:
        Xç         Fill X with spaces.
           +Y      Append Y.
                 Implicit: output result of last expression

Ancienne version, 10 octets:

òV £P=ç +X

Testez-le en ligne!

 òV £  P= ç +X
UòV mX{P=Pç +X}  Ungolfed
                 Implicit: U, V = inputs, P = empty string
UòV              Create the range [U, U+1, ..., V-1, V].
    mX{       }  Map each item X to:
         Pç        Fill P with spaces.
            +X     Append X.
       P=          Re-set P to the result.
                   Implicitly return the same.
                 Implicit: output result of last expression

D, 133 127 126 125 125 121 119 octets

import std.conv,std.stdio;void f(T)(T a,T b,T s=0){for(T j;j++<s;)' '.write;a.writeln;if(a-b)f(a+1,b,s+a.text.length);}

Jelly et APL ont été prises.

Essayez-le en ligne!

Si vous êtes d'accord avec les résultats dépendants de la console (va sur le même principe que la réponse C de Giacomos), voici un pour 72 71 octets:

import std.stdio;void f(T)(T a,T b){while(a<=b){a++.write;'\v'.write;}}

Comment? (Uniquement des astuces spécifiques à D)

• f(T)(T a,T b,T s=0) Le système de modèles de D peut déduire des types
• for(T j;j++<s;)Les entiers sont définis par défaut sur 0.
• ' '.write;a.writelnD vous permet d'appeler fun(arg)comme arg.fun(une des rares choses golfiques que D a)
• a.text.lengthComme ci-dessus, et D vous permet également d'appeler une méthode sans paramètres comme s'il s'agissait d'une propriété ( textc'est la conversion en chaîne)
• Une chose qui pourrait être pertinente (je ne l'ai pas utilisé cependant) peut être dans les chaînes!

Java 8, 79 octets

(a,b)->{for(String s="";a<=b;System.out.printf("%"+s.length()+"d\n",a++))s+=a;}

Essayez-le en ligne!