Зростання діапазону!


14

Ваше завдання полягає в тому, щоб, задавши два натуральних числа, x і n , повернути перші x числа в послідовності інкрементальних діапазонів.

Послідовність інкрементального діапазону спочатку генерує діапазон від одного до n включно. Наприклад, якби n було 3 , це створило б список [1,2,3] . Потім він неодноразово додає останні n значень, збільшених на 1 до існуючого списку, і продовжує.

Вхід n=3 наприклад:

n=3
1. Get range 1 to n. List: [1,2,3]
2. Get the last n values of the list. List: [1,2,3]. Last n=3 values: [1,2,3].
3. Increment the last n values by 1. List: [1,2,3]. Last n values: [2,3,4].
4. Append the last n values incremented to the list. List: [1,2,3,2,3,4]
5. Repeat steps 2-5. 2nd time repeat shown below.

2nd repeat:
2. Get the last n values of the list. List: [1,2,3,2,3,4]. Last n=3 values: [2,3,4]
3. Increment the last n values by 1. List: [1,2,3,2,3,4]. Last n values: [3,4,5].
4. Append the last n values incremented to the list. List: [1,2,3,2,3,4,3,4,5]

Тестові приклади:

n,   x,   Output
1,  49,   [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49]
2, 100,   [1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,30,30,31,31,32,32,33,33,34,34,35,35,36,36,37,37,38,38,39,39,40,40,41,41,42,42,43,43,44,44,45,45,46,46,47,47,48,48,49,49,50,50,51]
3,  13,   [1,2,3,2,3,4,3,4,5,4,5,6,5]

Відповіді:



7

Желе , 4 байти

Ḷd§‘

Дьядична посилання, що приймає два натуральних числа, xзліва та nсправа, що дає список натуральних чисел.

Спробуйте в Інтернеті!

Як?

Ḷd§‘ - Link: x, n              e.g   13, 3
Ḷ    - lowered range (x)             [0,1,2,3,4,5,6,7,8,9,10,11,12]
 d   - divmod (n)                    [[0,0],[0,1],[0,2],[1,0],[1,1],[1,2],[2,0],[2,1],[2,2],[3,0],[3,1],[3,2],[4,0]]
  §  - sums                          [0,1,2,1,2,3,2,3,4,3,4,5,4]
   ‘ - increment (vectorises)        [1,2,3,2,3,4,3,4,5,4,5,6,5]

3
Зачекайте ... це дивомода? Розумний! І я боровся з p...
Ерік Атголфер


6

05AB1E , 6 байт

L<s‰O>

Відповідь Желі на порту @JonathanAllan , тому обов'язково підтримайте його!

Перший вхід - х, другий вхід - н.

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

L       # Push a list in the range [1, (implicit) input]
        #  i.e. 13 → [1,2,3,4,5,6,7,8,9,10,11,12,13]
 <      # Decrease each by 1 to the range [0, input)
        #  → [0,1,2,3,4,5,6,7,8,9,10,11,12]
  s    # Divmod each by the second input
        #  i.e. 3 → [[0,0],[0,1],[0,2],[1,0],[1,1],[1,2],[2,0],[2,1],[2,2],[3,0],[3,1],[3,2],[4,0]]
    O   # Sum each pair
        #  → [0,1,2,1,2,3,2,3,4,3,4,5,4]
     >  # And increase each by 1
        #  → [1,2,3,2,3,4,3,4,5,4,5,6,5]
        # (after which the result is output implicitly)

Мій власний початковий підхід складав 8 байт :

LI∍εN¹÷+

Перший вхід - н, другий вхід - х.

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

L         # Push a list in the range [1, (implicit) input]
          #  i.e. 3 → [1,2,3]
 I       # Extend it to the size of the second input
          #  i.e. 13 → [1,2,3,1,2,3,1,2,3,1,2,3,1]
   ε      # Map each value to:
    N¹÷   #  The 0-based index integer-divided by the first input
          #   → [0,0,0,1,1,1,2,2,2,3,3,3,4]
       +  #  Add that to the value
          #   → [1,2,3,2,3,4,3,4,5,4,5,6,5]
          # (after which the result is output implicitly)


4

Мозок-Флак , 100 байт

(<>)<>{({}[()]<(({}))((){[()](<{}>)}{}){{}{}<>(({})<>)(<>)(<>)}{}({}[()]<(<>[]({}())[()]<>)>)>)}{}{}

З коментарями та форматуванням:

# Push a zero under the other stack
(<>)<>

# x times
{
    # x - 1
    ({}[()]<

        # Let 'a' be a counter that starts at n
        # Duplicate a and NOT
        (({}))((){[()](<{}>)}{})

        # if a == 0
        {
            # Pop truthy
            {}
            <>

            # Reset n to a
            (({})<>)

            # Push 0 to each
            (<>)(<>)
        }

        # Pop falsy
        {}

        # Decrement A, add one to the other stack, and duplicate that number under this stack
        ({}[()]<
            (<>[]({}())<>)
        >)
    >)
}

Спробуйте в Інтернеті!


4

J , 13 12 байт

[$[:,1++/&i.

Спробуйте в Інтернеті!

як

Ми беремо xяк лівий аргумент, nяк правий. Візьмемо x = 8і n = 3для цього приклад:

  • +/&i.: Перетворіть обидва аргументи, створивши цілі діапазони i., тобто лівий аргумент стає, 0 1 2 3 4 5 6 7а правий аргумент стане 0 1 2. Тепер ми створюємо "таблицю додавання +/з цих двох:

     0 1 2
     1 2 3
     2 3 4
     3 4 5
     4 5 6
     5 6 7
     6 7 8
     7 8 9
    
  • 1 +: Додайте 1 до кожного елемента цієї таблиці:

     1 2  3
     2 3  4
     3 4  5
     4 5  6
     5 6  7
     6 7  8
     7 8  9
     8 9 10
    
  • [: ,: Вирівняти ,:

     1 2 3 2 3 4 3 4 5 4 5 6 5 6 7 6 7 8 7 8 9 8 9 10
    
  • [ $: Сформуйте $так, щоб він мав таку ж кількість елементів, що і вихідний, неперетворений лівий аргумент [, тобто x:

     1 2 3 2 3 4 3 4 
    


4

Октава , 25 байт

@(n,x)((1:n)'+(0:x))(1:x)

Анонімна функція, яка вводить числа nта xта виводить векторний рядок.

Спробуйте в Інтернеті!

Як це працює

Розглянемо n=3і x=13.

Код (1:n)'дає вектор стовпця

1
2
3

Потім (0:x)дає векторний рядок

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

Доповнення (1:n)'+(0:x)є елементарним з трансляцією, і тому воно дає матрицю з усіма парами сум:

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

Індексація за допомогою (1:x)витягує перші xелементи цієї матриці в лінійному порядку основного стовпця (вниз, потім поперек), як векторний рядок:

1 2 3 2 3 4 3 4 5 4 5 6 5

3

Haskell , 31 байт

n#x=take x$[1..n]++map(+1)(n#x)

Спробуйте в Інтернеті!

Це може бути моїм улюбленим видом рекурсії. Почнемо зі значень від 1 до n, а потім об'єднаємо ті самі значення (за допомогою самонавіювання) +1. тоді ми просто беремо перші значення x.


2

Четвертий (gforth) , 34 байти

: f 0 do i over /mod + 1+ . loop ;

Спробуйте в Інтернеті!

Пояснення коду

: f            \ start a new word definition
  0 do         \ start a loop from 0 to x-1
    i          \ put the current loop index on the stack
    over       \ copy n to the top of the stack
    /mod       \ get the quotient and remainder of dividing i by n
    + 1+       \ add them together and add 1
    .          \ output result
  loop         \ end the counted loop
;              \ end the word definition

2

MATL , 16 , 10 байт

:!i:q+2G:)

Спробуйте в Інтернеті!

-6 байтів збережено завдяки Гвізеппе та Луїсу Мендо!

Пояснення:

:!          % Push the array [1; 2; ... n;]
  i:q       % Push the array [0 1 2 ... x - 1]
     +      % Add these two arrays with broadcasting
      2G    % Push x again
        :)  % Take the first x elements

@LuisMendo Дякую! Ясна річ, я досить іржавий зі своїм MATL :)
Джеймс,








1

Stax, 6 bytes

⌐çYæ▄9

Run and debug it

Unpacked & explained:

rmx|%+^ Full program, implicit input (n, x on stack; n in register X)
r       Range [0 .. x)
 m      Map:
  x|%     Divide & modulo x
     +    Add quotient and remainder
      ^   Add 1
          Implicit output


0

Charcoal, 18 bytes

NθFN⊞υ⊕⎇‹ιθι§υ±θIυ

Try it online! Link is to verbose version of code. I had dreams of seeding the list with a zero-indexed range and then slicing it off again but that was actually 2 bytes longer. Explanation:

Nθ                  Input `n` into variable
   N                Input `x`
  F                 Loop over implicit range
         ι          Current index
        ‹           Less than
          θ         Variable `n`
       ⎇   ι        Then current index else
               θ    Variable `n`
              ±     Negated
            §υ      Cyclically indexed into list
      ⊕             Incremented
    ⊞υ              Pushed to list
                Iυ  Cast list to string for implicit output

0

JS, 54 bytes

f=(n,x)=>Array.from(Array(x),(_,i)=>i+1-(i/n|0)*(n-1))

Try it online!


Welcome to PPCG :) As this isn't a recursive function, you don't need to count the f=. You can save one byte by currying the parameters (n=>x=>) and another by spreading & mapping the array ([...Array(x)].map()).
Shaggy





0

C (стук), 843 байт

#include <stdlib.h>
main(int argc, char* argv[]){
        int x,n;
        if (argc == 3 && (n = atoi(argv[1])) > 0 && (x = atoi(argv[2])) > 0){ 
                int* ranges = calloc(x, sizeof *ranges);
                for (int i = 0; i < x; i++){
                        if (i < n){ 
                                ranges[i] = i+1;
                        }   
                        else {
                                ranges[i] = ranges[i-n] + 1;
                        }   
                }   
        printf("[");
        for (int j = 0; j < x - 1; j++){
                printf("%d",ranges[j]);
                printf(",");
        }   
        printf("%d",ranges[x - 1]);
        printf("]\n");
        free(ranges);
        }   
        else {
                printf("enter a number greater than 0 for n and x\n");
        }   
}

2
Hi, welcome to PPCG! This challenge is tagged [code-golf], which means you have to complete the challenge in as few as possible bytes/characters. You can remove loads of whitespaces, and change variable names to single characters in your code (the argc, argv and ranges). Also, no need to add any warning messages.. You can assume the input is valid, unless the challenge says otherwise.
Kevin Cruijssen



Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.