У нас много горизонтальных осей для чисел, но я, честно говоря, думаю, что они довольно скучные. Ваша задача сегодня состоит в том, чтобы построить мне часть диагональной оси между двумя разными неотрицательными целыми числами, заданными в качестве входных данных.

Как построить диагональную ось?

• Давайте рассмотрим пример с вводом 0, 5. Наша ось должна выглядеть так:

  0
   1
    2
     3
      4
       5
  

• Тем не менее, наша ось должна выглядеть хорошо для чисел, которые также имеют больше цифр! Если вход является, например 0, 14, новая ось должна быть:

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

• Идея состоит в том, что первая цифра следующего числа на оси всегда должна располагаться точно после последней цифры предыдущего числа. Чтобы понять идею еще лучше, вот еще один пример с 997, 1004:

  +997
     998
        999
           1000
               1001
                   1002
                       1003
                           1004
  

правила

• Вы можете предположить, что ввод находится в порядке возрастания или убывания (вы можете выбрать между 5,3и 3,5).

• Вы также можете предположить, что разница между двумя целыми числами меньше 100.

• У вас может быть начальный перевод строки или последовательный пробел (в каждой строке). Трейлинг-пробелы / переводы строк тоже хороши.

• По умолчанию лазейки запрещены.

• Вы можете принимать входные данные и предоставлять выходные данные любым стандартным способом .

• Это код-гольф , поэтому выигрывает самый короткий код в байтах на каждом языке!

Другие тестовые случаи

• 1, 10:

  1
   2
    3
     4
      5
       6
        7
         8
          9
           10
  

• 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 байт

Спасибо Magic Octopus Urn за сохранение байта!

Это как-то работает, но, честно говоря, я понятия не имею, почему.

Код

Ÿvy.O=

Использует кодировку 05AB1E . Попробуйте онлайн!

объяснение

Ÿ          # 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 байта

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

Использует вертикальную вкладку для создания эффекта лестницы. Способ \vвизуализации зависит от консоли, поэтому он может работать не везде (например, TIO).

Древесный уголь , 9 8 байт

Ｆ…·ＮＮ⁺¶ι

Попробуйте онлайн!

Ссылка на подробную версию кода. Ввод в порядке возрастания.

• 1 байт сохранен благодаря ASCII-только!

R 70 69 61 байт

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

Функция, которая принимает переменные начала и конца в качестве аргументов. Зацикливает последовательность и печатает каждый элемент с добавлением достаточного количества пробелов. Fначинается как FALSE=0, и во время каждой итерации к ней добавляется количество символов для этого значения. Fопределяет количество напечатанных пробелов.

Попробуйте онлайн!

-8 байт благодаря @Giuseppe

C #, 90 89 85 байт

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

Сохранено 1 байт благодаря @LiefdeWen.
Сохранено 4 байта благодаря @auhmaan.

Попробуйте онлайн!

Полная / Отформатированная версия:

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 байта

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

Попробуйте онлайн!

Mathematica, 59, байтов

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

вход

[10,15]

-3 байта @JungHwanMin
проблема с 0 исправлена ​​(подробности см. В комментариях),
спасибо @ngenisis

Желе , 9 байт

rD⁶ṁ$;¥\Y

Попробуйте онлайн!

Mathematica, 48 байтов

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

так как есть так много ответов, я подумал, что этот должен быть включен

вход

[0,10]

выход

C 166 134 95 82 байта

Новый ответ

Просто как функция, а не как целая программа.

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

Спасибо Фалькену за помощь в удалении 13 байт (и исправлении ошибки)!

Спасибо Стеф Хен за помощь в сбивании 12 байт!

Спасибо Zacharý за помощь сбить 1 байт!

Старые ответы

Избавился от int перед main и изменил const char * v [] на char ** v и избавился от 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. Не уверен, правильно ли я отформатировал это, но я получал удовольствие, делая это!

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

объяснение

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

использование

C ++, 167 165 байт

-2 байта благодаря 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 байта

-1 спасибо Захари .

Предполагается, что ⎕IO←0отсчет начинается с нуля. Принимает нижнюю границу в качестве левого аргумента и верхнюю границу в качестве правого аргумента.

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

Попробуйте онлайн!

(… ) Применить следующую неявную функцию между аргументами:

 - вычтите верхнюю нижнюю из верхней границы

 1- вычесть это из одного (то есть 1 + ∆)

 ⊣+∘⍳ левая нижняя граница плюс целые 0 через это

 ⍕¨ форматировать (stringify) каждый

{… } Примените к нему следующую анонимность (обозначенную ⍵):

 ≢¨ длина каждого (число)

 +\ накопленная сумма

 - NEGATE

 ⍵↑⍨¨ для каждого строкового числа возьмите столько символов с конца (пробелы с пробелами)

 ↑ смешать список строк в символьную матрицу

Сетчатка , 81 78 байт

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

Попробуйте онлайн! Принимает ввод как разделенный новой строкой список из двух целых чисел. Редактировать: 3 байта были сохранены путем кражи кода расширения диапазона из моего ответа на вопрос : разделяем ли мы основной кластер? Объяснение:

.+
$*

Преобразовать оба входа в унарный.

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

Хотя последние два элемента (a, b) списка отличаются более чем на 1, замените их на (a, a + 1, b). Это расширяет список из кортежа в диапазон.

1+
$.& $.&

Конвертировать обратно в десятичный в дубликате.

 (.+)
$.1$* 

Преобразуйте дубликат копии в пробелы.

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

Суммируйте суммы пробелов от каждой строки до следующей.

Pyth , 14 13 байтов

V}FQ
=k+*dlkN

Попробуйте онлайн!

LOGO , 53 байта

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

Нет "Попробуй онлайн!" ссылка, потому что все онлайн переводчик LOGO не поддерживает список шаблонов.

Это список шаблонов (эквивалент лямбда-функции в других языках).

Использование:

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

( applyвызывает функцию)

распечатает

997
   998
      999
         1000
             1001
                 1002
                     1003
                         1004

Заметка:

Здесь используется черепаха ycor(Y-координата) для хранения количества пробелов, необходимых для ввода, поэтому:

• Черепаха должна быть переведена домой в положение по умолчанию и направление (вверх) перед каждым вызовом.
• windowдолжен быть выполнен, если ycorстановится слишком большим, чтобы черепаха соскочила с экрана. Описание windowкоманды: в if the turtle is asked to move past the boundary of the graphics window, it will move off screen.отличие от настройки по умолчанию wrap, котораяif 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.

Объяснение:

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 байтов

Ÿʒ¾ú=þv¼

Попробуйте онлайн!

-2 спасибо Аднану .

JavaScript (ES8), 69 67 62 байта

Принимает ввод в виде целых чисел в порядке возрастания с использованием синтаксиса каррирования. Возвращает массив строк.

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

Попытайся

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 байт

òV
£¯Y ¬ç +X

Принимает ввод в любом порядке и всегда возвращает числа в порядке возрастания в виде массива строк.

Попробуйте онлайн!с -Rфлагом, чтобы присоединить массив с символами новой строки.

объяснение

Неявный ввод Uи V.

òV
£

Создать инклюзивный диапазон [U, V]и сопоставить каждое значение с ...

¯Y ¬ç

Значения перед current ( ¯Y), объединенные в string ( ¬) и заполненные пробелами ( ç).

+X

Плюс текущий номер. Результирующий массив неявно выводится.

Python 2 , 65 63 62 61 байт

-2 байта благодаря @Mr. Xcoder: execне нужны брекеты

-1 до свидания благодаря @ Zacharý: print s*' 'какprint' '*s

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

Попробуйте онлайн!

JavaScript, 57 байт

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

Python 2, 60 59 байт

-1 байт, спасибо Mr.Xcoder за определение моего s = 0 как необязательной переменной в моей функции.

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

Попробуйте онлайн!

Я думаю, что это можно перенести в лямбда-версию, но я не знаю как. Я также думаю, что между пробелами и длиной текущего числа есть какое-то отображение, но об этом я тоже еще не разобрался. Поэтому я думаю, что еще есть возможности для улучшения.

Я создал диапазон от нижней границы lдо верхней границы, uпечатая каждую строку с пробелом, умноженным на число s. Я увеличиваю множитель с длиной текущего числа.

Python 2, 78 77 79 байтов

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

Попробуйте онлайн!

f(A, B) напечатает часть оси между A и B включительно.

Первый раз отвечаю на вызов!

Использует и использует обратные метки Python 2 для подсчета количества пробелов, которые он должен добавить перед числом.

-1 байт благодаря Mr.Xcoder

+2 потому что я забыл +1

С (ССЗ) , 41 38 байт

-3 байта благодаря ASCII-только

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

Работает на RedHat6, доступ через PuTTY

Попробуйте онлайн!

V , 16 байтов

ÀñÙywÒ $pça/jd

Попробуйте онлайн!

Это было бы намного проще, если бы я мог взять start end - start но я думаю, что это слишком сильно меняет задачу.

Это принимает начальный номер в качестве ввода в буфере и конечный номер в качестве аргумента. Фактически он создает лестницу из startв, start + endа затем удаляет все после конечного числа.

MATL , 11 байт

vii&:"t~@Vh

Попробуйте онлайн!

объяснение

Это работает путем генерации строки для каждого числа и конкатенации ее с логически отрицательной копией предыдущей строки. Таким образом, char 0 добавляется 0 столько раз, сколько длина предыдущей строки. Char 0 отображается в виде пробела, а каждая строка отображается в отдельной строке

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 байт

Я думаю, что никто бы не опубликовал решение Swift в любом случае ...

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

Попробуйте онлайн!

Perl, 19 байт

Примечание: \x0bсчитается одним байтом.

Наряду с другими, я думал, что использование движений курсора будет кратчайшим путем, это означает, что он не работает на TIO:

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

использование

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

Japt , 10 9 байт

òV åÈç +Y

Проверьте это онлайн! Возвращает массив строк; -RФлаг включен, чтобы присоединиться к новым строкам для удобства просмотра.

объяснение

 ò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

Старая версия, 10 байт:

òV £P=ç +X

Проверьте это онлайн!

 ò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 121 119 байт

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

Желе и APL были взяты.

Попробуйте онлайн!

Если вы согласны с результатами, зависящими от консоли (не соответствует тому же принципу, что и ответ Giacomos на C), вот один для 72 71 байта:

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

Как? (Только D конкретные приемы)

• f(T)(T a,T b,T s=0) Система шаблонов D может выводить типы
• for(T j;j++<s;)Целые по умолчанию 0.
• ' '.write;a.writelnD позволяет вам звонить fun(arg)как arg.fun(одна из немногих вещей в гольф D имеет)
• a.text.lengthТо же, что и выше, и D также позволяет вам вызывать метод без параметров, как если бы это было свойство ( textэто преобразование в строку)
• Одна вещь, которая может иметь отношение (хотя я не использовал это), новые строки могут быть в строках!

Java 8, 79 байт

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

Попробуйте онлайн!