Given two integers, output the two integers, and then the range between them (excluding both).
The order of the range must be the same as the input.
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]
Ÿ¦¨«
Explanation
Ÿ # inclusive range [a ... b]
¦¨ # remove the first and last element
« # append to input
lambda a,b:[a,b,*range(a,b,-(a>b)|1)[1:]]
Combined former implementations.
or-1 to save a byte.
\$\endgroup\$
Commented
Nov 8, 2018 at 9:56
lambda x:x+range(*x,-cmp(*x)|1)[1:]
Thanks to @nwellnhof for golfing off 1 byte!
lambda x:x+range(*x+[-cmp(*x)|1])[1:]
Thanks to @JonasAusevicius for the port to CPython!
lambda x:x+range(*x+[-cmp(*x)|1])[1:]. Nice solution
\$\endgroup\$
{|@_,|[...^](@_).skip}
{ }
|@_, # Slip args a,b into result
[...^](@_) # Reduce args a,b with ...^ operator, same as a...^b
.skip # Skip first element
| # Slip into result
-(y<x)|1. very cool but I can't work out why it works! Any chance you can explain it?
\$\endgroup\$
y<x checks if y is strictly less than x, and returns True if it is, False otherwise. After that, unary - is applied to it, which converts True to -1 and False to 0. The last step is to bitwise OR this number with 1. This obviously leaves 1 (0b1) unaffected, and also leaves -1 (-0b1) unaffected (the sign bit of -1 is set, so it's kept as such). However, it does convert 0 to 1, so that range doesn't complain about me using a step of 0.
\$\endgroup\$
Commented
Nov 8, 2018 at 19:32
lambda a,b:[a,b]+[*range(a+1,b)]+[*range(a-1,b,-1)]
lambda a,b:[a,b]+range(a+1,b)+range(a-1,b,-1)
a<=b and from both answers
\$\endgroup\$
+ instead of or
\$\endgroup\$
lambda a,b:[a,b,*range(a+1,b),*range(a-1,b,-1)]
\$\endgroup\$
Commented
Nov 14, 2018 at 20:48
lambda a,b:[a,b]+range(a,b,a<b or-1)[1:]
Here's mine, now that a lot of other Python answers have been posted
-6 bytes, thanks to G B
a<b or-1 is shorter for the 3rd range parameter. The shortest I got was lambda x,y:[x,y]+range(x+(x<y or-1),y,x<y or-1)
\$\endgroup\$
cUr!õ kU
:Implicit input of array U
c :Concatenate
Ur : Reduce U by
!õ : Inclusive range
kU : Remove all elements in original U
4,4 test case...
\$\endgroup\$
Commented
Jan 24, 2021 at 14:12
,œ|r
,œ|r Main link. Left argument: a. Right argument: b
, Pair; yield [a, b].
r Range; yield [a, ..., b].
œ| Perform multiset union.
Takes input as (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
Using a space-delimited String:
b->a->{var r=a+" "+b;for(;a<b?++a<b:--a>b;)r+=" "+a;return r;}
Using a List:
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 can be ++a<b||(a-=2)>b for the same byte-count: Try it online for the String or Try it online for the List.)
Old (109 108 104 102 101 bytes) answer using an array:
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 bytes thanks to @nwellnhof.
Explanation:
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
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 bytes)
\$\endgroup\$
Commented
Nov 8, 2018 at 12:11
var, which is why I usually put those at 8, and the ones that does use var as 10 (and the ones using String.repeat as 11). :) Forgot to update it after adding the List and String answers, should be corrected now. Thanks.
\$\endgroup\$
Commented
Nov 9, 2018 at 10:51
Anonymous infix function.
,,…~,
, the first and last (lit. the concatenation of the arguments)
, and (lit. concatenated to)
… the range
~ without
, the first and last (lit. the concatenation of the arguments)
b-1 as b $ (-1). Use b- 1 instead.
\$\endgroup\$
Commented
Nov 10, 2018 at 20:34
NegativeLiterals on.
\$\endgroup\$
Commented
Nov 10, 2018 at 21:15
,,[|.@]^:(>{.)<.+1}.i.@|@-
A dyadic verb (takes left and right argument)
- 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
,,[:}.@}:<.+i.@-@(+*)@- for 23 bytes and no special casing on relative argument ordering (rather: it's hidden inside the signum *). i feel like this could get down under 20 but i'm tired.
\$\endgroup\$
,,<.+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
i. with negative argument.
\$\endgroup\$
Commented
Nov 8, 2018 at 17:40
@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
Takes input as command-line arguments. Explanation:
@echo %1
@echo %2
Output the two integers.
@for %%s in (1 -1)do
Try both ascending and descending ranges.
@for /l %%i in (%1,%%s,%2)do
Loop over the inclusive range.
@if %1 neq %%i if %%i neq %2
Exclude the two integers.
echo %%i
Output the current value.
+QtrF
Input is a two-element list, [input 1, input 2]. Try it online here, or verify all the test cases at once here.
+QtrFQ Implicit: Q=eval(input())
Trailing Q inferred
rFQ Generate range [input 1 - input 2)
t Discard first element
+Q Prepend Q
F instead of .* on 2-element lists is a brilliant trick that I will absolutely be using from here on.
\$\endgroup\$
func[a b][s: sign? d: b - a prin[a b]loop absolute d - s[prin[""a: a + s]]]
->a,b{[a,b]+[*a..b,*a.downto(b)][1..-2]}
Temporary fix, trying to find a better idea
[4,4] this gives only one [4]
\$\endgroup\$
Commented
Nov 8, 2018 at 9:36
lambda i,j:[i,j]+range(i,j,(i<j)*2-1)[1:]
-5 with thanks to @JoKing
-6 by slicing the first element from the range (idea stolen from and with credit to @TFeld)
Non-lambda version...
i,j=input();print[i,j]+range(i,j,(i<j)*2-1)[1:]
-2 with thanks to @JoKing
function t($a,$b){count($r=range($a,$b))>1?array_splice($r,1,0,array_pop($r)):$r=[$a,$b];print_r($r);}
Unfortunately (for golf) PHP has rather verbose function names, which contribute a lot to the length. But the basic idea is to create a range, then pop off the last element and stitch it back in at offset 1. For the 4,4 example I had to add count($r=range($a,$b))>1?...:$r=[$a,$b]; which adds quite a bit, and unfortunately array_splice() is by reference which hit me for a few more bytes ($r= and a ;). All because of that "edge case", lol.
Well anyway enjoy!
function t($a,$b){$o=array($a,$b);for($i=$a+1;$i<$b;$i++)$o[]=$i;print_r($o);}
\$\endgroup\$
Commented
Nov 10, 2018 at 21:47
function t($a,$b){echo $a.$b;for($i=$a+1;$i<$b;$i++)echo $i};
\$\endgroup\$
Commented
Nov 10, 2018 at 21:48
(fn[[a b]](def s(if(> a b)-1 1))(list* a b(range(+ a s)b s)))
An anonymous function that takes a 2-vector as input and returns a list.
(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
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;}
A port of @HatsuPointerKun's C++ answer into D.
-1 byte from Misha Lavrov
Prompt A,B
Disp A,B
cos(π(A>B
For(I,A+Ans,B-Ans,Ans
Disp I
End
1-2(A>B with cos(π(A>B.
\$\endgroup\$
Commented
Nov 8, 2018 at 20:55
seq( wouldn't work for inputs where A and B are the same, unfortunately :(
\$\endgroup\$
Commented
Nov 8, 2018 at 22:33
seq(, so I'm no longer convinced it even is smaller. Still, the cos( trick should help.
\$\endgroup\$
Commented
Nov 8, 2018 at 22:34
Without recursion:
(s,e,m=s>e?-1:1)=>[s,e,...[...Array(m*(e-s||1)-1)].map((_,i)=>s+m*(i+1))]
Try it:
f=(s,e,m=s>e?-1:1)=>[s,e,...[...Array(m*(e-s||1)-1)].map((_,i)=>s+m*(i+1))]
console.log(JSON.stringify(f(0,5)));
console.log(JSON.stringify(f(-3,8)));
console.log(JSON.stringify(f(4,4)));
console.log(JSON.stringify(f(4,5)));
console.log(JSON.stringify(f(8,2)));
console.log(JSON.stringify(f(-2,-7)));
ＩＥ²ＮＩ…⊕θηＩ⮌…⊕ηθ
Try it online! Link is to verbose version of code. Explanation:
ＩＥ²Ｎ
Print the inputs on separate lines.
Ｉ…⊕θη
Print the ascending range, if any.
Ｉ⮌…⊕ηθ
Print the reverse ascending reverse range, if any.