वृद्धिशील रंग!


14

आपका कार्य दो धनात्मक पूर्णांक, और , पहले संख्या को वृद्धिशील श्रेणियों के अनुक्रम में लौटाएं ।xnx

वृद्धिशील सीमा अनुक्रम पहले एक से करने के लिए एक सीमा उत्पन्न समावेशी। उदाहरण के लिए, यदि था , तो यह सूची उत्पन्न करेगा । यह फिर मौजूदा सूची में से बढ़ाए गए अंतिम मानों को बार-बार जोड़ता है , और जारी रखता है।nn3[1,2,3]n1

उदाहरण के लिए का इनपुट :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

आर , 33 बाइट्स

function(n,x,z=1:x-1)z%%n+z%/%n+1

इसे ऑनलाइन आज़माएं!

पोर्ट्स जोनाथन एलन का पायथन समाधान

आर , 36 बाइट्स

function(n,x)outer(1:n,0:x,"+")[1:x]

इसे ऑनलाइन आज़माएं!

मेरा मूल समाधान; वेतन वृद्धि के रूप में प्रत्येक कॉलम के साथ एक n×x मैट्रिक्स उत्पन्न करता है , अर्थात, 1n,2n+1, , तो पहले x प्रविष्टियां लेता है (स्तंभ नीचे जा रहा है)।


6

05AB1E , 6 बाइट्स

L<s‰O>

पोर्ट @JonathanAllan के जेली जवाब है , तो उसे बनाए रखने के लिए सुनिश्चित करें!

पहला इनपुट x , दूसरा इनपुट n

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें

स्पष्टीकरण:

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¹÷+

पहला इनपुट n , दूसरा इनपुट x

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें

स्पष्टीकरण:

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

जे , 13 12 बाइट्स

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

इसे ऑनलाइन आज़माएं!

किस तरह

हम xबाएं आर्ग के nरूप में, दाएं के रूप में लेते हैं । के ले चलते हैं x = 8और n = 3इस उदाहरण के लिए:

  • +/&i.: पूर्णांक श्रेणीएँ बनाकर दोनों आर्गों को बदल दें i., यानी बाएँ arg बन जाता है 0 1 2 3 4 5 6 7और दाएँ arg बन जाता है 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

हास्केल , 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 :)
जेम्स










0

चारकोल , 18 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। मेरे पास शून्य-अनुक्रमित सीमा के साथ सूची को सीडिंग करने और फिर इसे बंद करने के सपने थे, लेकिन यह वास्तव में 2 बाइट्स लंबा था। स्पष्टीकरण:

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

जेएस, 54 बाइट्स

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

इसे ऑनलाइन आज़माएं!


PPCG में आपका स्वागत है :) जैसा कि यह एक पुनरावर्ती कार्य नहीं है, आपको गिनती करने की आवश्यकता नहीं है f=। आप एक बाइट को पैरामीटर्स ( n=>x=>) और दूसरे को ऐरे से फैलाकर और मैप करके बचा सकते हैं [...Array(x)].map()
झबरा





0

सी (क्लैंग), 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
नमस्ते, PPCG में आपका स्वागत है! इस चुनौती को [कोड-गोल्फ] टैग किया जाता है, जिसका अर्थ है कि आपको चुनौती को यथासंभव बाइट्स / वर्णों में पूरा करना होगा। आप व्हॉट्सएप के भार को हटा सकते हैं, और अपने कोड ( argc, argvऔर ranges) में एकल वर्णों के लिए चर नाम बदल सकते हैं । इसके अलावा, कोई चेतावनी संदेश जोड़ने की आवश्यकता नहीं है .. आप मान सकते हैं कि इनपुट वैध है, जब तक कि चुनौती अन्यथा न कहे।
केविन क्रूज़सेन



हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.