पहला, अंतिम और सब कुछ

Question

दो पूर्णांकों को देखते हुए, दो पूर्णांकों का उत्पादन करते हैं, और फिर उनके बीच की सीमा (दोनों को छोड़कर)।

सीमा का क्रम इनपुट के समान होना चाहिए।

उदाहरण:

 Input        Output
 0,  5   ->   [0, 5, 1, 2, 3, 4]
-3,  8   ->   [-3, 8, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7]
 4,  4   ->   [4, 4]
 4,  5   ->   [4, 5]
 8,  2   ->   [8, 2, 7, 6, 5, 4, 3]
-2, -7   ->   [-2, -7, -3, -4, -5, -6]

Comments

मुझे लगता है कि हम पूर्व-क्रम में इनपुट नहीं ले सकते हैं?

— केविन क्रूज़सेन

@KevinCruijssen, नहीं, आउटपुट ऑर्डर इनपुट ऑर्डर पर निर्भर करता है

— TFeld

@StewieGriffin, आउटपुट ऑर्डर को इनपुट के समान होना चाहिए

— TFeld

क्या यह आउटपुट स्वरूप स्वीकार्य है? नई लाइन पर ध्यान दें

— लुइस मेन्डो

@ केविनक्रूजसेन कोई भी उचित I / O स्वीकार्य है।

— 13

Answer 1

आर , ३ ९ ३३ ३० बाइट्स

c(a<-scan(),setdiff(a:a[2],a))

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

सहेजे गए बाइट के लिए धन्यवाद user2390246 और J.Doe।

Comments

आप दो अलग-अलग पूर्णांकों के बजाय एक वेक्टर के रूप में इनपुट लेकर कुछ बाइट्स बचा सकते हैं।

— user2390246

हाँ, यह उचित है, और यह वास्तव में तब फ़ंक्शन के बजाय एक पूर्ण कार्यक्रम के रूप में भी छोटा हो जाता है।

— किरिल एल।

आप इस तथ्य का दुरुपयोग कर सकते हैं कि :ऑपरेटर 30 बाइट्स के

— आर्गों

Answer 2

05AB1E , 4 बाइट्स

Ÿ¦¨«

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

व्याख्या

    Ÿ      # inclusive range [a ... b]
     ¦¨    # remove the first and last element
       «   # append to input

Answer 3

पायथन 3 , 52 48 47 42 41 बाइट्स

lambda a,b:[a,b,*range(a,b,-(a>b)|1)[1:]]

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

---

संयुक्त पूर्व कार्यान्वयन।

Comments

आप or-1एक बाइट को बचाने के लिए स्थान को हटा सकते हैं ।

— केविन क्रूज़सेन

Answer 4

पायथन 2 (साइथन) , 36 35 बाइट्स

lambda x:x+range(*x,-cmp(*x)|1)[1:]

1 बाइट गोल्फिंग के लिए @nwellnhof को धन्यवाद!

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

---

पायथन 2 , 37 बाइट्स

lambda x:x+range(*x+[-cmp(*x)|1])[1:]

CPython के बंदरगाह के लिए @JonasAusevicius को धन्यवाद!

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

Comments

यह 37 बाइट्स में मानक पायथन 2 पर लागू किया जा सकता है, जिससे यह अभी तक का सबसे छोटा जवाब है lambda x:x+range(*x+[-cmp(*x)|1])[1:]:। अच्छा समाधान

— जोनास ऑसेविसियस

Answer 5

पर्ल 6 , 26 22 बाइट्स

{|@_,|[...^](@_).skip}

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

व्याख्या

{                    }
 |@_,   # Slip args a,b into result
      [...^](@_)  # Reduce args a,b with ...^ operator, same as a...^b
                .skip  # Skip first element
     |  # Slip into result

Answer 6

पायथन 2 , 40 बाइट्स

lambda x,y:[x,y]+range(x,y,-(y<x)|1)[1:]

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

Comments

वास्तव में पसंद है -(y<x)|1। बहुत अच्छा है, लेकिन मैं बाहर काम नहीं कर सकता क्यों यह काम करता है! कोई भी मौका आप इसे समझा सकते हैं?

— ElPedro 19

@ElPedro मूल रूप से, y<xजाँच करता है कि yक्या सख्ती से कम है x, और Trueअगर यह है, तो वापस आ Falseजाता है। उसके बाद, -इसे लागू किया जाता है, जो Trueकरने के लिए -1और Falseकरने के लिए धर्मान्तरित है 0। अंतिम चरण बिटवाइज़ या इस नंबर के साथ है 1। यह स्पष्ट रूप से अप्रभावित है 1( 0b1और अप्रभावित है) भी छोड़ देता है -1( -0b1संकेत का बिट -1सेट है, इसलिए इसे इस तरह रखा गया है)। हालांकि, यह परिवर्तित करता है 0करने के लिए 1, ताकि rangeएक का उपयोग कर मुझे के बारे में शिकायत नहीं कर रहा है stepकी 0।

— आउटगोल्फर

यह गंभीर रूप से शांत और बहुत चालाक है। अगर मैं दो बार उत्थान कर सकता हूं। स्पष्टीकरण के लिए बहुत धन्यवाद।

— एलपेड्रो

Answer 7

पायथन 3, 64 62 51 बाइट्स

lambda a,b:[a,b]+[*range(a+1,b)]+[*range(a-1,b,-1)]

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

पायथन 2, 58 45 बाइट्स

lambda a,b:[a,b]+range(a+1,b)+range(a-1,b,-1)

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

Comments

क्योंकि एक खाली सूची गलत है, आप a<=b and दोनों जवाबों से हटा सकते हैं

— TFeld

आप +इसके बजाय का उपयोग कर सकते हैंor

— TFeld

@TFeld धन्यवाद

— जोनास ऑसेविसियस

पायथन 3 डाउन टू 47 बाइट्स:lambda a,b:[a,b,*range(a+1,b),*range(a-1,b,-1)]

— मैपेटिलियन

Answer 8

जाप, 8 बाइट्स

cUr!õ kU

इसे यहाँ आज़माएँ

             :Implicit input of array U
c            :Concatenate
 Ur          :  Reduce U by
   !õ        :   Inclusive range
      kU     :  Remove all elements in original U

Answer 9

जावास्क्रिप्ट (ईएस 6), 51 बाइट्स

के रूप में इनपुट लेता है (a)(b)।

a=>g=(b,c=b)=>(b+=b<a|-(b>a))-a?[...g(b,c),b]:[a,c]

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

टिप्पणी की गई

a =>                // main function, taking a
  g = (             // g = recursive function
    b,              //     taking b
    c = b           // we save a backup of the original value of b into c
  ) =>              //
    (b +=           // add to b:
      b < a |       //   +1 if b is less than a
      -(b > a)      //   -1 if b is greater than a
    )               //   (or 0 if b = a)
    - a ?           // if the updated value of b is not equal to a:
      [             //   generate a new array:
        ...g(b, c), //     prepend all values generated by a recursive call
        b           //     append the current value of b
      ]             //
    :               // else:
      [a, c]        //   stop recursion and return the first 2 values: a and c

Answer 10

पायथन 2 , 47 41 40 बाइट्स

lambda a,b:[a,b]+range(a,b,a<b or-1)[1:]

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

यहाँ मेरा है, अब जब कि पायथन के कई अन्य उत्तर पोस्ट किए गए हैं

_{-6 बाइट्स, जीबी के लिए धन्यवाद}

Comments

खाली सीमा का लाभ उठाते हुए जब यह अमान्य है तो आगे या पीछे की सूचियों से निपटने का एक स्मार्ट तरीका है। मैं देख सकता था कि यह बहुत उपयोगी है और यह जानने के लिए एक अच्छी चाल है।

— एकोजी

एक सीमा का उपयोग करते हुए 41 बाइट्स: रेंज (ए, बी, (ए <बी) * 2-1)

— जीबी

a<b or-13 श्रेणी पैरामीटर के लिए छोटा है। मुझे जो सबसे छोटा मिला वह थाlambda x,y:[x,y]+range(x+(x<y or-1),y,x<y or-1)

— mbomb007

Answer 11

जावा 10, 109 108 104 102 93 62 बाइट्स

स्पेस-सीमांकित स्ट्रिंग का उपयोग करना:

b->a->{var r=a+" "+b;for(;a<b?++a<b:--a>b;)r+=" "+a;return r;}

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

सूची का उपयोग करना:

b->a->{var r=new java.util.Stack();for(r.add(a),r.add(b);a<b?++a<b:--a>b;)r.add(a);return r;}

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

( एक ही बाइट-काउंट के लिए a<b?++a<b:--a>bहो सकता है ++a<b||(a-=2)>b: स्ट्रिंग के लिए इसे ऑनलाइन आज़माएँ या सूची के लिए इसे ऑनलाइन आज़माएँ ।)

---

एक सरणी का उपयोग करके पुरानी ( 109 108 104 102 101 बाइट्स) उत्तर:

a->b->{int s=a<b?1:-1,i=a!=b?(b-a)*s+1:2,r[]=new int[i];for(r[0]=a,r[1]=b;i>2;)r[--i]=b-=s;return r;}

-7 बाइट्स @nwellnhof को धन्यवाद ।

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

स्पष्टीकरण:

a->b->{                // Method with 2 int parameters & int-array return-type
  int s=               //  Step integer, starting at:
        a<b?1          //   1 if the first input is smaller than the second
        :-1;           //   -1 otherwise
      i=               //  Array-index integer, starting at:
        a!=b?          //   If the inputs aren't equal:
         (b-a)*s+1     //    Set it to the absolute difference + 1
        :              //   Else:
         2,            //    Set it to 2
      r[]=new int[i];  //  Result-array of that size
  for(r[0]=a,          //  Fill the first value with the first input
      r[1]=b;          //  And the second value with the second input
      i>2;)            //  Loop `i` downwards in the range [`i`,2):
    r[--i]=            //   Decrease `i` by 1 first with `--i`
                       //   Set the `i`'th array-value to:
           b-=s;       //    If the step integer is 1: decrease `b` by 1
                       //    If the step integer is -1: increase `b` by 1
                       //    And set the array-value to this modified `b`
  return r;}           //  Return the result-array

Comments

पूर्णांक की श्रेणी बनाने के लिए जावा के मानक पुस्तकालय में कुछ भी नहीं है? या यह अभी भी उपयोग करने के लिए क्रिया है?

— Οurous

@ (Urous यह वास्तव में बहुत अधिक क्रिया है: a->b->{var L=java.util.stream.IntStream.range(a,b).boxed().collect(java.util.Collectors.toList());L.add(0,b);L.add(0,a);return L;}(130 बाइट्स)

— केविन क्रूज़सेन

यह जावा 8 या जावा 10 है? "वर" ^ ^ ^ '' के कारण

— Neyt

@ नियत अह, नियत। नीचे दिए गए ऐरे के साथ मेरे शुरुआती संस्करण का उपयोग नहीं किया गया var, यही कारण है कि मैं आमतौर पर उन 8 को डाल देता हूं, और जो var10 के रूप में उपयोग करते हैं (और String.repeat11 के रूप में उपयोग करने वाले )। :) सूची और स्ट्रिंग उत्तरों को जोड़ने के बाद इसे अपडेट करना भूल गए, अब इसे ठीक किया जाना चाहिए। धन्यवाद।

— केविन क्रूज़सेन

Answer 12

APL (Dyalog Extended) , 5 बाइट्स

अनाम शिशु फ़ंक्शन।

,,…~,

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

, पहला और अंतिम (वाद-विवादों का सिलसिला)

, और (जलाया गया)

… क्षेत्र

~ के बिना

, पहला और अंतिम (वाद-विवादों का सिलसिला)

Comments

अच्छा, तो मुझे लगता है कि आप अब से अपने सभी गोल्फ के लिए इसका उपयोग करने जा रहे हैं?

— ज़ाचारि

@ Zacharý शायद केवल अगर कोड काफी छोटा या सरल है।

— Adám

Answer 13

हास्केल, 34 बाइट्स

a#b=a:b:[a+1..b-1]++[a-1,a-2..b+1]

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

Comments

यह काम नहीं करता। GHC के b-1रूप में व्याख्या करता है b $ (-1)। b- 1इसके बजाय उपयोग करें ।

— स्कुलुर्मिन

@MarkNeu: यह काम करता है। TIO लिंक देखें।

— नीमी

मुझे माफ करें! मैं पर था NegativeLiterals।

— schuelermine

Answer 14

जेली , 4 बाइट्स

,œ|r

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

यह काम किस प्रकार करता है

,œ|r  Main link. Left argument: a. Right argument: b

,     Pair; yield [a, b].
   r  Range; yield [a, ..., b].
 œ|   Perform multiset union.

Answer 15

जे , 26 बाइट्स

,,[|.@]^:(>{.)<.+1}.i.@|@-

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

स्पष्टीकरण:

एक रंग क्रिया (बाएं और दाएं तर्क लेता है)

                         -    subtracts the arguments
                       |@     and finds the absolute value
                    i.@       and makes a list 0..absolute difference
                 1}.          drops the fist element
                +             adds to the entire list
              <.              the smaller of the arguments
   |.@]                       reverses the list
       ^:                     only if
  [                           the left argument
         (>{.)                is greater than the first item of the list
 ,                            appends the list to
,                             the right argument appended to the left one

Comments

,,[:}.@}:<.+i.@-@(+*)@-23 बाइट्स के लिए और रिश्तेदार तर्क आदेश पर कोई विशेष आवरण नहीं है (बल्कि: यह साइनम के अंदर छिपा हुआ है *)। मुझे लगता है कि यह 20 से कम हो सकता है लेकिन मैं थक गया हूं।

— जोनाह

@ जोना धन्यवाद! Btw FrownyFrog समाधान मेरे से बेहतर है, इसलिए मैं इसे किसी भी आगे गोल्फ नहीं जा रहा हूँ।

— गैलेन इवानोव

Answer 16

ऑक्टेव , 45 बाइट्स

@(a,b)[a b linspace(a,b,(t=abs(a-b))+1)(2:t)]

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

Comments

यदि पहला दूसरे से बड़ा है, तो रेंज का

— अवतरण

अरे यार, मैं नहीं पढ़ सकता

— लुइस मेन्डो

मैंने भाषा को बदलना समाप्त कर दिया

— लुइस मेंडू

Answer 17

जे , 13 बाइट्स

,,<.+i.@-~-.=

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

     i.@-~       range [0 .. |difference|-1], reverse if the difference is positive
          -.=    remove the zero (either "=" is 0 or there’s nothing to remove)
  <.+            to each element add the smaller of the args
,,               prepend args

Comments

अच्छा समाधान! मैं i.नकारात्मक तर्क के साथ पूरी तरह से भूल गया ।

— गैलेन इवानोव

यह शानदार है!

— जोनाह

Answer 18

बैच, 107 बाइट्स

@echo %1
@echo %2
@for %%s in (1 -1)do @for /l %%i in (%1,%%s,%2)do @if %1 neq %%i if %%i neq %2 echo %%i

कमांड-लाइन तर्कों के रूप में इनपुट लेता है। स्पष्टीकरण:

@echo %1
@echo %2

दो पूर्णांक आउटपुट।

@for %%s in (1 -1)do

आरोही और अवरोही दोनों श्रेणियों का प्रयास करें।

@for /l %%i in (%1,%%s,%2)do

समावेशी रेंज पर लूप।

@if %1 neq %%i if %%i neq %2

दो पूर्णांकों को छोड़ दें।

echo %%i

आउटपुट वर्तमान मूल्य।

Answer 19

अजगर , 5 बाइट्स

+QtrF

इनपुट, एक दो तत्व सूची है [input 1, input 2]। इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

+QtrFQ   Implicit: Q=eval(input())
         Trailing Q inferred
   rFQ   Generate range [input 1 - input 2)
  t      Discard first element
+Q       Prepend Q

Comments

2-तत्व सूचियों के Fबजाय का उपयोग करना .*एक शानदार चाल है जिसे मैं पूरी तरह से यहां से उपयोग करूंगा।

— 16:14 बजे hakr14

Answer 20

लाल , 75 बाइट्स

func[a b][s: sign? d: b - a prin[a b]loop absolute d - s[prin[""a: a + s]]]

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

Answer 21

क्लीन , 49 बाइट्स

import StdEnv
@a b=init[a,b:tl[a,a+sign(b-a)..b]]

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

Answer 22

रूबी , 33 40 बाइट्स

->a,b{[a,b]+[*a..b,*a.downto(b)][1..-2]}

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

अस्थायी सुधार, एक बेहतर विचार खोजने की कोशिश कर रहा है

Comments

इसके लिए [4,4]केवल एक देता है[4]

— किरिल एल।

आप सही हैं, मैंने इसे ठीक किया।

— GB

Answer 23

पायथन 2 , 52 47 41 बाइट्स

lambda i,j:[i,j]+range(i,j,(i<j)*2-1)[1:]

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

-5 @ धन्यवाद के साथ

-6 सीमा से पहला तत्व टुकड़ा करके (विचार चोरी से और @TFeld से क्रेडिट के साथ)

नॉन-लैम्ब्डा संस्करण ...

पायथन 2 , 51 49 47 बाइट्स

i,j=input();print[i,j]+range(i,j,(i<j)*2-1)[1:]

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

-2 @JoKing के साथ धन्यवाद

Answer 24

APL (Dyalog Classic) , 29 बाइट्स

{⍺,⍵,(⌽⍣(⍺>⍵))(⍺⌊⍵)+¯1↓⍳|⍺-⍵}

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

मेरे Jसमाधान का एक बंदरगाह

Comments

वाह, मुझे आश्चर्य है कि यह एक सरल कार्य के लिए इतना लंबा है।

— क्विंटec

@ क्विंट शायद यह गोल्फ हो सकता है, या शायद एक और एल्गोरिथ्म के परिणामस्वरूप बहुत कम समाधान होगा।

— गैलन इवानोव

Answer 25

PHP (102 बाइट्स)

function t($a,$b){count($r=range($a,$b))>1?array_splice($r,1,0,array_pop($r)):$r=[$a,$b];print_r($r);}

सैंडबॉक्स

दुर्भाग्य से (गोल्फ के लिए) PHP में क्रिया नामों के नाम हैं, जो लंबाई में बहुत योगदान करते हैं। लेकिन मूल विचार यह है कि एक सीमा बनाई जाए, फिर अंतिम तत्व को पॉप ऑफ करें और इसे ऑफ़सेट में वापस सिलाई करें। 1. उदाहरण के 4,4लिए मुझे जोडना था, count($r=range($a,$b))>1?...:$r=[$a,$b];जो थोड़ा बहुत जोड़ता है, और दुर्भाग्य array_splice()से संदर्भ से है जो मुझे कुछ और के लिए मारता है बाइट्स ($r= and a ; )। उस "बढ़त मामले" के कारण सभी, योग्य।

खैर वैसे भी आनंद!

Comments

मुझे नहीं लगता कि यह कोड गोल्फ के लिए एक सही दृष्टिकोण है। function t($a,$b){$o=array($a,$b);for($i=$a+1;$i<$b;$i++)$o[]=$i;print_r($o);}

— th3pirat3

या ऐसा कुछfunction t($a,$b){echo $a.$b;for($i=$a+1;$i<$b;$i++)echo $i};

— th3pirat3

यह एक फंक्शन होना है और इसे एक एरे को आउटपुट करना है। यदि आपके पास अपना बेहतर उत्तर है तो इसे पोस्ट करने का स्वागत करें।

— ArtisticPhoenix

मैंने इसे संपादित किया है, क्या अब एक वैध प्रस्तुत करना है? क्या मैं इसे एक नए उत्तर के रूप में रखूंगा या क्या?

— 213 बजे th3pirat3

यह पूरी तरह से आप पर निर्भर है, मैं बस इसे बिना लूप के करना चाहता था ... lol

— ArtisticPhoenix

Answer 26

क्लोजर , 61 बाइट्स

(fn[[a b]](def s(if(> a b)-1 1))(list* a b(range(+ a s)b s)))

एक अनाम फ़ंक्शन जो इनपुट के रूप में 2-वेक्टर लेता है और एक सूची देता है।

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

व्याख्या

(fn [[a b]] ; An anonymous function that accepts a 2-vector as input, and destructures it to a and b
  (def s (if (> a b) -1 1)) ; If a > b assigns -1 to s and assigns 1 to s otherwise. This determines the order of the elements of the output list.
  (list* a b ; Creates a list with a and b as the first two elements. The remaining elements will be appended from the following range:
    (range (+ a s) b s))) ; A range starting at a+s and ending at b with step s

Answer 27

डी , 85 बाइट्स

T[]f(T)(T a,T b){T[]v=[a,b];T c=2*(b>a)-1;for(T i=a+c;a!=b&&b!=i;i+=c)v~=i;return v;}

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

@ HatsuPointerKun के C ++ का एक पोर्ट D में उत्तर देता है।

Answer 28

टीआई-बेसिक, 35 34 बाइट्स

मिशा लावरोव से -1 बाइट

Prompt A,B
Disp A,B
cos(π(A>B
For(I,A+Ans,B-Ans,Ans
Disp I
End

Comments

और एक और बाइट के 1-2(A>Bसाथ बदलकर cos(π(A>B।

— मिशा लावरोव

@MishaLavrov seq(इनपुट्स के लिए काम नहीं करेगा जहां Aऔर Bसमान हैं, दुर्भाग्य से :(

— kamoroso94

सच - भी, मैंने एक तर्क छोड़ दिया seq(, इसलिए मैं अब आश्वस्त नहीं हूं कि यह छोटा है। फिर भी, cos(चाल में मदद करनी चाहिए।

— मिशा लावरोव

Answer 29

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

ＩＥ²ＮＩ…⊕θηＩ⮌…⊕ηθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

ＩＥ²Ｎ

अलग-अलग लाइनों पर इनपुट प्रिंट करें।

Ｉ…⊕θη

आरोही रेंज प्रिंट करें, यदि कोई हो।

Ｉ⮌…⊕ηθ

यदि कोई हो, रिवर्स आरोही रिवर्स रेंज प्रिंट करें।

Answer 30

डार्ट , 85 84 बाइट्स

f(a,b)=>[a,b]+((a-b).abs()>1?List.generate((a-b).abs()-1,(i)=>(a>b?-i-1:i+1)+a):[]);

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

-1 से जा रहा >=है>