| Bytes | Lang | Time | Link |
|---|---|---|---|
| 028 | Regenerate a | 250212T130918Z | Unrelate |
| 070 | Python 2 | 250211T040000Z | Lucenapo |
| 027 | Pip | 240525T162603Z | DLosc |
| 071 | Perl 5 Mbigint p | 240514T212927Z | Xcali |
| 110 | Python 3 | 240514T130447Z | None1 |
| 064 | TIBASIC | 240511T205313Z | Sylveste |
| 017 | Vyxal 3 | 240511T003719Z | lyxal |
| 018 | Vyxal | 240511T002236Z | lyxal |
| 020 | 05AB1E | 240510T093741Z | Kevin Cr |
| 026 | Pyth | 240509T160815Z | CursorCo |
| 046 | APL+WIN | 240509T085604Z | Graham |
| 037 | Charcoal | 240509T084506Z | Neil |
| 053 | JavaScript Node.js | 240509T073708Z | l4m2 |
Regenerate -a, 29 28 bytes
([1489])(00+)$0{#2*2%($1%5)}
-1 thanks to DLosc (lmao)
Outputs infinitely.
([1489])
Generate the leading digit in group 1.
(00+)
Generate the zeroes, 2 or more, in group 2.
$0{#2*2%($1%5)}
Succeed and output only if twice the number of zeroes (was accidentally the square of the number of zeroes) is divisible by the leading digit mod 5. (1 -> 1, 4 -> 4, 8 -> 3, 9 -> 4)
Python 2, 70 bytes
n=input()
print'14918149114891'[n%14]+'0'*(~-n*3/7+2+(1577>>(n%14))%2)
0-indexed input
Pip, 27 bytes
W PtPB0P*t*Y489FE1=#t%Y%_+2
Outputs infinitely. Attempt This Online!
Explanation
This is an interesting challenge. I'm far from certain that this is the golfiest approach possible.
W PtPB0P*t*Y489FE1=#t%Y%_+2
; t is initially 10
W ; While this value is truthy...
tPB0 ; Append a 0 to t (i.e. multiply it by 10)
P ; Print and return it
; ... loop:
; (t will always be nonzero and therefore truthy)
489FE ; Filter the digits of 489 based on a function of their
; indices (0, 1, 2):
%_ ; Index mod 2 (0, 1, 0)
+2 ; plus 2 (2, 3, 2)
#t ; Length of t (1 more than the power of 10 that t is)
%Y ; Take the length mod the 2, 3, or 2 from above
1= ; Is the result equal to 1?
t*Y ; Multiply the digits that remain by t
P* ; Print each of the results
Perl 5 -Mbigint -p, 71 bytes
$_=(sort{(log$a)-log$b}map{$z=10**$_,4*$z**2,9*$z**2,8*$z**3}1..$_)[$_]
Takes n as an input and output's the n-th item in the sequence, 1-indexed.
Python 3, 110 bytes
n=int(input());k=lambda x,y:[x*(10**y)**i for i in range(1,n+1)];print(sorted(k(1,1)+k(4,2)+k(8,3)+k(9,2))[n])
This answer is a bit long, let me know if it can be improved.
Queries the n-th term prompted by input, 1-indexed.
This first generates the sequence in wrong order and then sorts it.
TI-BASIC, 64 bytes
Input T
For(I,1,T
₁₀^(I→P
8P³→L₁(1+dim(L₁
augment(L₁,augment(seq(J²P²,J,2,3),{10P→L₁
End
SortA(L₁
L₁(T
This calculates the sequence, sorts it (the calculation generates the correct numbers but in the wrong order), and outputs the requested number of the sequence.
Here is an example with an input of 3. The output is 900 (yes, it's 1-indexed):
Vyxal 3, 17 bytes
…ɾĖ:∥ᵛTd∥3*;²WfSi
Uses the latest technology of arity grouping and properly implemented parallel apply. Ports my Vyxal 2 answer.
Vyxal, 18 bytes
⇧ɾ↵:₌vTd:3e‟"²Wfsi
A silly little answer. 1-indexed, outputs the nth item.
Explained
⇧ɾ↵:₌vTd:3e‟"²Wfsi
⇧ɾ # range [1, n + 2]
↵ # 10 ^ x for x in the above
: # duplicate, and
₌vTd # Triple each item, and double each item, separately
:3e # duplicate the double list, and cube each value
‟ # rotate the stack right so that the triple and double lists are back on top
"² # pair into a single list and square each item
W # Wrap the entire stack into a list. This gives [cubes of 2*10^n, 10^n list, squares of [3*10^n, 2*10^n]]
fs # flatten and sort that. Note that this includes 10 at the start, which is 10^1.
i # which is why the output is 1-indexed :p. Get the n-th item, 0-indexed, but n = 1 skips over the edge case of 10^1.
💎
Created with the help of Luminespire.
05AB1E, 25 20 bytes
∞¦°εŽ5×SDyÒgs5%ÖÏ*}˜
-5 bytes porting @CursorCoercer's Pyth answer, so make sure to upvote that answer as well!
Outputs the infinite sequence.
Original 25 bytes answers:
∞<°2Å€ƵmS*}3Å€¸˜¬8*ª{}¦¦˜
Outputs the infinite sequence.
A port of @l4m2's alternative JavaScript approach is 25 bytes as well:
•A¨Ý›¹ •∞èεN6*46+y-14÷<°*
Outputs the infinite sequence.
Explanation:
∞ # Push an infinite positive list: [1,2,3,...]
¦ # Remove the leading 1: [2,3,4,...]
° # Take 10 to the power each: [100,1000,10000,...]
ε # Map each to:
Ž5× # Push compressed integer 1489
S # Convert it to a list of digits: [1,4,8,9]
D # Duplicate it
y # Push the current power of 10 value
Ò # Pop and get its prime factors
g # Pop and push the length
s # Swap so the duplicated [1,4,8,9] is at the top
5% # Modulo-5 each
Ö # Check whether the amount of prime factors is divisible by [1,4,8,4]
Ï # Only keep the digits from list [1,4,8,9] at the truthy positions
* # Multiply each to the current power of 10 value
}˜ # After the map: flatten the list of lists
# (after which the infinite list is output implicitly as result)
∞ # Push an infinite positive list: [1,2,3,...]
< # Decrease each by 1 to make it a non-negative list: [0,1,2,...]
° # Take 10 to the power each: [1,10,100,1000,...]
2Å€ } # Map every 2nd value (index%2==0) to:
Ƶm # Push compressed integer 149
S # Convert it to a list of digits: [1,4,9]
* # Multiply each digit to the current value
3Å€ } # Then map every 3rd value (index%3==0) to:
¸˜ # Wrap into a list and flatten (e.g. 1000 becomes [1000] and
# [1000000,4000000,9000000] remains unchanged)
¬ # Get the first item of this list (without popping)
8* # Multiply it by 8
ª # Append it to the list
{ # Sort it (to fix the order of the values starting with 9,8)
¦¦ # Then remove the first two values ([1,4,8,9] and 10)
˜ # Flatten
# (after which the infinite list is output implicitly as result)
•A¨Ý›¹ • # Push compressed integer 11491814911489
∞ # Push an infinite positive list: [1,2,3,...]
è # 0-based modular index into the earlier integer: [1,4,9,...]
ε # Then map over each digit:
N # Push the current 0-based map-index
6* # Multiply it by 6
46+ # Add 46
y- # Subtract the current digit
14÷ # Integer-divide it by 14
< # Subtract that by 1
° # Take 10 to the power that
* # Multiply it to the current digit
# (after which the infinite list is output implicitly as result)
See this 05AB1E tip of mine (section How to compress large integers?) to understand why Ž5× is 1489; Ƶm is 149; and •A¨Ý›¹ • is 11491814911489.
Pyth, 26 bytes
KT#=*KTj*LKf!%lPK%T5j1489T
Outputs the infinite sequence.
Explanation
KT # assign K = 10
# # enter infinite loop
=*KT # assign K = K * 10
j1489T # list [1, 4, 8, 9]
f # filter list on lambda T
lPK # length of the list of prime factors of K
% %T5 # modulo (T % 5)
! # true if 0
*LK # map list over multiplication by K
j # print list joined on newlines
APL+WIN, 46 bytes
Prompts for number of terms:
n↑1↓m[⍋m←∊((↑¨m)*3),((m←iר⊂2 3)*2),i←10*⍳n←⎕]
Charcoal, 37 bytes
ＮθＩ…ΦＥ⊗θ×Ｉ§1489ιＸχ⁺²÷ι⁴¬﹪⊖Ｌι⁻³↔⁻²﹪κ⁴θ
Try it online! Link is to verbose version of code. Explanation:
Ｎθ Input `n` as an integer
θ Input `n`
⊗ Doubled
Ｅ Map over implicit range
1489 Literal string `1489`
§ Cyclically indexed by
ι Current value
Ｉ Cast to string
× Multiplied by
χ Predefined variable `10`
Ｘ Raised to power
² Literal integer `2`
⁺ Plus
ι Current value
÷ Integer divided by
⁴ Literal integer `4`
Φ Filtered where
ι Current value
Ｌ Length
⊖ Decremented
¬﹪ Is divisible by
³ Literal integer `3`
⁻ Subtract
² Literal integer `2`
↔⁻ Absolute difference with
κ Current index
﹪ Modulo
⁴ Literal integer `4`
… θ Take the first `n` terms
Ｉ Cast to string
Implicitly print
Using the method of @l4m2's JavaScript solution to output the first n terms is also 37 bytes:
ＩＥＮ×Ｉ§”)¶k✳ï↑;¹”ιＸχ⁺׳÷ι⁷Ｉ§”)⊞∨+γ⊗<”ι
Try it online! Link is to verbose version of code. Explanation:
Ｎ Input `n` as a number
Ｅ Map over implicit range
”...” Compressed string `14918149114891`
§ Cyclically indexed by
ι Current index
Ｉ Cast to integer
× Multiplied by
χ Predefined variable `10`
Ｘ Raised to power
³ Literal integer `3`
× Multiplied by
ι Current index
÷ Integer divided by
⁷ Literal integer `7`
⁺ Plus
”...” Compressed string `22233441233334`
§ Cyclically indexed by
ι Current index
Ｉ Cast to integer
Ｉ Cast to string
Implicitly print
JavaScript (Node.js), 53 bytes
n=>(c='14918149114891'[n%14]).padEnd(n/7*3+3.5-c/9,0)
-2 from Arnauld
-1 from Tbw