Given an integer n as input, return a list containing n, repeated n times. For example, the program would take 5 and turn it into [5,5,5,5,5]. The elements need to be integers, not strings. No built-in functions that accomplish the task are allowed.
This is code-golf, so standard rules apply.
a:n uni on a a:na
nolla a:na on tyhjyys
a:n seuraaja o:na on o lisättynä a:han o:na
Explanation:
a:n uni on a a:na
uni(a) = f(a,a)
nolla a:na on tyhjyys
f(0, a) = []
a:n seuraaja o:na on o lisättynä a:han o:na
f(a +1, o) = o : f(a, o)
uni(a) = f(a,a)
f(0 ,a) = []
f(a+1,o) = o : f(a,o)
PHP, 19 Bytes
I'm new here can anyone tell if this is ok ?
for(;$b--;)$a[]=$n;
EDIT:
looks to not be a valid form so :
32 Bytes (by Titus)
(+1 Byte for R flag)
for($b=$argn;$b--;)echo$argn,_;
for($a=$argn;$argn--;)$b[]=$a;echo implode(',',$b); would work. echo$a=$argn;for(;--$argn;)echo',',$a; would be better though ;) You would be allowed to submit a function but they are usally longer in php :/
\$\endgroup\$
Aug 22, 2017 at 6:24
function a($b){for($n=$b;$b--;)$a[]=$n;return$a;} would be valid for example.
\$\endgroup\$
Aug 22, 2017 at 6:29
for($b=$argn;$b--;)echo$argn,_; (and don´t forget to count +1 for the R flag)
\$\endgroup\$
->n{[n]*n}
Sample run:
irb(main):001:0> ->n{[n]*n}[5]
=> [5, 5, 5, 5, 5]
->n{Array.new n,n}
Sample run:
irb(main):001:0> ->n{Array.new n,n}[5]
=> [5, 5, 5, 5, 5]
{@($_)*$_}
PS C:\> 2 | % {@($_)*$_}
2
2
And:
PS C:\> 5 | % {@($_)*$_}
5
5
5
5
5
By default, PowerShell shows array content one element per line. Running it through the ConvertTo-Json cmdlet shows it in a more familiar form:
PS C:\> 5 | % {@($_)*$_} | ConvertTo-Json -Compress
[5,5,5,5,5]
5 | % {@($_)*$_}? If so you don't need the 3 bytes ($f=) required to name the function.
\$\endgroup\$
This assumes an empty list
Ans→dim(L₁:L₁+Ans
Here's the hex, along with the code to explain the byte count:
72 04 B5 5D 00 3E 5D 00 70 71
Ans → dim( L₁ : L₁ + Ans
Ans→dim(L₁:L₁+Ans
Ans→dim(L₁ Since the list is empty, this makes L₁ a list on Ans 0's
: Separator
L₁+Ans Since TI-Basic vectorizes some commands,
this adds Ans (basically the input here) to each element in L₁,
which results in Ans for each element.
rand( isn't a thing. It's Ans + 0 rand ( Ans.
\$\endgroup\$
ceiling() to save a byte
\$\endgroup\$
n=>System.Linq.Enumerable.Repeat(n,n)
Old version for 38 bytes:
n=>"".PadLeft(n,(char)n).ToCharArray()
A char in C# is an int underneath so this appears to be valid.
using System.Linq;n=>new int[n].Select(_=>n)
If the above is invalid this is for an extra 6 bytes.
new string... note the lower case :) Though yes it is the same length unfortunately.
\$\endgroup\$
Aug 21, 2017 at 16:22
n=>Enumerable.Repeat(n,n)
\$\endgroup\$
Aug 24, 2017 at 10:08
Ans+0rand(Ans
Thanks to @Oki for this solution!
0 can be replaced with lots of things (int(/iPart(, imag(, angle(, ...). Alternative solution: Ansnot(not(rand(Ans. Other noteworthy solutions (1 byte longer) randInt(Ans,Ans,Ans, Ansrand(Ans)^0, Ans(1^rand(Ans, -Ansint(-rand(Ans
\$\endgroup\$
_2:'[2:`]
_ input
2: double the input
' push one to control stack
[2:`] for (number), double it, output one of them
({}){({})}{}
$ ./flurry -inn -c "({}){({})}{}" 3
3 3 3
$ ./flurry -inn -c "({}){({})}{}" 6
6 6 6 6 6 6
This uses the "push x y times" construct y {({})} x, just that in this case both are the input number n.
({}) Pop and push n; evaluates to n
{({})} A lambda that returns its argument unchanged,
pushing its argument once onto the stack
{} Pop n
DÄWî
DÄWî
D duplicate
Ä push n onto the stack n times
W wrap the stack in a list
î cast to integer
[:rep]
This is an anonymous function that takes input on the stack and leaves output on the stack. This simply takes the input, duplicates it, then repeats the input by the input.
INPUT a
DIM t(a)
FOR x=1TO a
t(x)=a
NEXT
Assumes the integer is on the stack already.
d×
This just duplicates the top stack element and then performs stack multiplication (i.e. Python's [x]*y).
∙r
Try it Here!
Outputs to the stack.
Explanation:
∙ multiply POP (string, defaults to input) by POP (number, defaults to the same input)
vertically - so to an array of strings
r swap types - convert the strings to numbers
{(({}[()])<>[]())<>}<>
Normally, the version that uses one stack would be shorter. However, in this case it's 6 bytes longer:
(({})){({}<(({}))>[()])}{}{}
ωi×ω+↵
ω, push the first command line argument evaluatedi, pop n; push [1...n]×, pop a; pop b; push b*a. 0 is popped when there is nothing on the stack. Since commands vectorize ("vecify" in MY), it ends up being an array of n 0's.ω, push the first command line argument evaluated+, pop a; pop b; push b+a. Adds the command line argument to every item in the array of 0 repeated n times, giving us n repeated n times↵, pop n; print n with a newline.
jot $1 $1 $1
This also works on Linux if the jot package is installed, e.g. sudo apt install athena-jot.
;α
Explanation:
;α
; duplicate the input
α push a list containing n copies of n
α is not a builtin for this challenge by the usual definition, because it does not solve this challenge by itself. α takes the top stack element (call it a) and repeats the next stack element (b) a times. It's roughly equivalent to iterable multiplication in Python ([5, 1]*2 == [5, 5, 1, 1]), but also works on non-iterables (52α yields [5, 5]).
3.700001000260201801500101010294
If you have concerns regarding the input format, please read this first.
Transpiles roughly as
grid[1] = grid[0] = input()
while grid[1] != 0:
print(grid[0])
grid[1] -= 1
1 is 48, and will print 1 (byte representation) 48 times.
\$\endgroup\$
#(repeat % %)
fun n=>(fix f k n:=match n with|0=>nil|S n=>(k::f k n)%list end) n n
Of course there's a library function, giving 46 bytes:
Require List. Definition f n:=List.repeat n n.
*aAa
*a : Multiply a times(Here, 8) [8,8,8,8,8,8,8,8]
A : List-ify a [8]
a: All a's will be assigned with the first input argument) 8
built-in. \$\endgroup\$*operator ok? What's an example of a built-in that isn't ok? \$\endgroup\$