Looping counter extended

Question

The looping counter is a challenge that prints an infinite number of lines. The first line has one *, the next line has one more * than this line. An example output is:

*
**
***
****
*****
******
*******
... (goes forever)

However, the question above is too simple and is a duplicate, so let's make it harder.

For every line, instead of printing *'s, print an uppercase English letter; also, the number of characters is not increased by one, but by the ASCII value of character in this line minus 64: the first line is one A, the second line is two B's, the third line is four C's, ..., the 26-th line is 326 Z's, the 27-th line is 352 A's, ...

A
BB
CCCC
DDDDDDD
EEEEEEEEEEE
FFFFFFFFFFFFFFFF
... (goes forever)

This is code-golf, so code in the fewest bytes.

Your output can be in any place (e.g.: Standard output, files, graphics, etc.), but must follow the format.

• noodle person: This is a duplicate of Count up forever because that task allows you to output in unary, which is essentially exactly this
• noodle person: Most solutions there which use decimal can be trivially modified to this by changing n=0;n+=1 to n='';n+='*'
• SanguineL: The character edit is also still trivial. Perhaps the entire idea is not really suitable for a challenge.
• Luis Mendo: @None1 When you make a change to the challenge, please notify the writers of existing answers that their answer has become invalid
• noodle person: I have left comments on invalid solutions, but next time open a new challenge instead of modifying an old one, the question was closed because it was a duplicate, doesn't mean you can't open a new one. Anyway what's been done has been done just keep that in mind for future challenges

Answer 1

Charcoal, 23 bytes

×ばつ⊕↨1+1%υ26§αLυD⎚⊞υLυ

Try it online! Link is to verbose version of code. Explanation:

W1«

Repeat forever.

×ばつ⊕↨1+1%υ26§αLυ

Reduce all of the members of the list modulo 26, increment each, take the sum, then increment that, and use that to repeat the current letter.

D⎚

Output the string and clear the canvas. (Normally Charcoal doesn't output until it terminates, but that's not useful for infinite output challenges.)

⊞υLυ

Push the current count to the predefined empty list.

Note that ⊕ works on empty lists in the newer version of Charcoal on ATO allowing it to replace +1 for a 1-byte saving.

If the number of lines was an input parameter and padded output was allowed then it would be possible in only 17 bytes (16 on ATO):

×ばつ⊕↨1+1%...0ι26§αι

Try it online! Link is to verbose version of code. Explanation:

 N Input number
E Map over implicit range
 α Predefined variable uppercase alphabet
 § Indexed by
 ι Current value
 ×ばつ Repeated by
 ... Range from
 0 Literal integer `0`
 ι To current value
 % Vectorised reduced modulo
 26 Literal integer `26`
 +1 Vectorised incremented
 ↨1 Summed
 ⊕ Incremented
 Implicitly print

The original challenge was possible in 5 bytes:

W1«*D

Try it online! Link is to verbose version of code. Explanation:

W1«

Repeat forever.

*

Append a * to the canvas.

D

Output the current contents of the canvas.

Note that Dump is throttled on TIO, making it take 5 seconds to fill the 128KB output buffer; it's about ×ばつ faster if you Attempt This Online! with the --nt option.

• Neil: @DLosc Finally got around to updating this; sorry for the delay.

Answer 2

Nekomata, 15 bytes

Ňr26%→Ɔ64+$∑→řH

Attempt This Online!

---

the original challenge, 5 bytes

'*ŇPř

Attempt This Online!

'*ŇPř
'* Push the character '*'
 Ň Choose a natural number
 P Check that it is positive
 ř Repeat the character that many times

Without any command-line flags, Nekomata will print all possible results separated by newlines.

Answer 3

JavaScript (Node.js), 74 bytes

for(i=0,s=1;;s+=i,i%=26)console.log(String.fromCharCode(++i+64).repeat(s))

Try it online!

(削除)

JavaScript (Node.js), 30 bytes

for(a='';;)console.log(a+='*')

Try it online!

Can't find a dup (削除ここまで)

Answer 4

Python 3, 45 bytes

a=b=1
while[print(chr(b+64)*a)]:a+=b;b=b%26+1

A full program that prints forever.

Try it online!

Answer 5

Retina 0.8.2, 46 bytes

$
@
{2=T`@L`L`(.)1円*
}2=`(.)1円*
$&1ドル
}:T`@L`LA

Try it online! Explanation:

$
@

Append an @.

2=T`@L`L`(.)1円*

Bump all of the characters up by one code point, but only in the second run of identical characters.

2=`(.)1円*
$&1ドル

Duplicate the last character, but only if there are two runs of identical characters.

{`
}`

Repeat until all of the letters are the same, at which point there is only one run of identical characters and so no substitutions are made.

:T`@L`LA

Bump all of the characters up by one code point, wrapping Z back around to A, and output the new string.

}`

Repeat forever, since the output keeps changing.

The original challenge was possible in 6 bytes:

+:`$
*

Try it online! Explanation:

+`

Repeat forever, since the output keeps changing.

:`

After performing the command, output the new value.

$
*

Append a * to the output.

This is a case where Retina 0.8.2 is golfier than Retina 1 where the * needs to be quoted with a $. (Retina 1 also uses \ instead of Retina 0.8.2's :.)

• noodle person: Challenge was updated, this is no longer valid
• Neil: @noodleman Finally got around to updating this; sorry for the delay.

Answer 6

C++, (削除) 113 (削除ここまで) 109 bytes

#include<iostream>
int i,p=1;int main(){while(p){std::cout<<std::string(p,char(i%26+65))<<'\n';p+=i++%26+1;}}

Try it online!

-4 bytes thanks to suggestions by Neil and ceilingcat.

• Neil: Moving the i++ into the p+= expression saves 2 bytes, but you can save 5 more by using a for loop.
• ceilingcat: 88 bytes

Answer 7

Java (JDK), (削除) 88 (削除ここまで) (削除) 87 (削除ここまで) 84 bytes

v->{for(int j=1,s=1,a;;s+=j,j=j%26+1)for(a=0;a<=s;)System.out.write(a++<s?j+64:10);}

Try it online!

• -1 byte after a discussion with corvus_192
• -3 bytes thanks to ceilingcat

+1 credit to this answer for the idea to use System.out.write with the ternary operator and this Javascript answer for the algorithm.

• corvus_192: -2 bytes: j%=26,s+=j++
• Glory2Ukraine: @corvus_192 Impossible, if we put modulo operation before the assignment of s, we are getting s=s+j%26 instead of s=s+j. This gives incorrect string lengthes after the 26th letter (Z). But this 1-byte reduction can still be done j=j%26+1 ;)

Answer 8

Perl 5 + -M5.10.0 -061, 38 bytes

$/+=$-,$-%=26while say+(A..Z)[$-++]x$/

Try it online!

Explanation

-061 sets $/ to 1 which starts our repetition counter where we need it.

while we say (always returns truthy) the letter of the alphabet, at index $- (starts at 0 and post-incremented), repeated $/ times, we increment $/ by $-, then set $- to itself, modulo 26.

Answer 9

R, 51 bytes

while(T<-T+F)cat(strrep(LETTERS[F<-F%%26+1],T),"
")

Try it online!

Answer 10

Python 3, 56 bytes

a,b=1,0
while 1:
 print(chr(b%26+65)*a)
 a+=b%26+1
 b+=1

Try it online!

Answer 11

PowerShell Core, 45 bytes

for(){([char]($c%26+65)+'')*++$i
$i+=$c++%26}

Try it online!

Answer 12

05AB1E, 14 bytes

1[DN&g×ばつ,N2%>+

Try it online.

Or alternatively:

AuÞ∞<2%>.\&g×ばつ,ドル

Try it online.

Original closed challenge (5 bytes):

'*[=Ć

Try it online.

Explanation:

1 # Start with 1
 [ # Loop indefinitely:
 D # Duplicate the current value
 N> # Push the 1-based loop-index
 .b # Convert it to an uppercase character (1→A,2→B,...,26→Z,27→A,...)
 ×ばつ # Repeat that letter the duplicated value amount of times
 , # Pop and print it with trailing newline
 N # Push the 0-based loop index
 2% # Modulo-26
 > # Increase it by 1
 + # Increase the current value by this for the next iteration

A # Push the lowercase alphabet
 u # Uppercase it
 Þ # Convert it to a list of characters, and cycle indefinitely
∞ # Push an infinite positive list: [1,2,3,...]
 < # Decrease by 1 to make it non-negative: [0,1,2,...]
 2% # Modulo-26 each
 > # Then increase each back by 1
 .\ # Prepend 0 and undelta
 > # Increase each by ×ばつ # Repeat the letters those values amount of times
 € # Loop over each string:
 , # Output it with trailing newline

'* '# Push "*"
 [ # Loop indefinitely:
 = # Print the current string with trailing newline (without popping)
 Ć # Enclose; append its own first character

Answer 13

Google Sheets, 103 bytes

To be entered in A1:

=LET(R,LAMBDA(R,a,b,i,l,IF(i=ROWS(A:A),l,R(R,a+b,MOD(b,26)+1,i+1,{l;REPT(CHAR(b+64),a)}))),R(R,1,1,1,))

enter image description here

The formula prints until the last row of the sheet. It breaks after a few thousand rows because of the 32k max char limitation of the REPT function.

enter image description here

Answer 14

Arturo, (削除) 58 (削除ここまで) 57 bytes

s:1i:0whileø->loop'A'..'Z'=>['s+i,[email protected]:s&|print'i+1]

enter image description here