text:
99 Varieties of Dosa
99 Varieties of Dosa is a popular chain of roadside dosa stalls across South India. This is inspired by a combination of this chain and the classic CodeGolf challenge "99 Bottles of Beer".
Recreate the variant of the menu of the popular '99 Varieties of Dosa' listed below.
(Note: Despite the name, the list contains 103 varieties and not exactly 99)
The desired output is the following list (in any order):
Sada Dosa
Cheese Sada Dosa
Paneer Sada Dosa
Paneer Cheese Sada Dosa
Schezwan Sada Dosa
Cheese Schezwan Sada Dosa
Paneer Schezwan Sada Dosa
Paneer Cheese Schezwan Sada Dosa
Onion Sada Dosa
Cheese Onion Sada Dosa
Paneer Onion Sada Dosa
Paneer Cheese Onion Sada Dosa
Chutney Dosa
Cheese Chutney Dosa
Paneer Chutney Dosa
Paneer Cheese Chutney Dosa
Tomato Onion Dosa
Cheese Tomato Onion Dosa
Paneer Tomato Onion Dosa
Paneer Cheese Tomato Onion Dosa
Schezwan Onion Dosa
Cheese Schezwan Onion Dosa
Paneer Schezwan Onion Dosa
Paneer Cheese Schezwan Onion Dosa
Jain Dosa
Jain Cheese Dosa
Jain Paneer Dosa
Jain Paneer Cheese Dosa
Masala Dosa
Cheese Masala Dosa
Paneer Masala Dosa
Paneer Cheese Masala Dosa
Onion Masala Dosa
Onion Paneer Masala Dosa
Cheese Onion Masala Dosa
Paneer Cheese Onion Masala Dosa
Schezwan Masala Dosa
Cheese Schezwan Masala Dosa
Paneer Schezwan Masala Dosa
Paneer Cheese Schezwan Masala Dosa
Mysore Masala Dosa
Paneer Mysore Masala Dosa
Cheese Mysore Masala Dosa
Paneer Cheese Mysore Masala Dosa
Paneer Cheese Schezwan Mysore Masala Dosa
Kerala Dosa
Kerala Cheese Dosa
Paneer Kerala Dosa
Paneer Cheese Kerala Dosa
Pav Bhaji Dosa
Pav Bhaji Cheese Dosa
Pav Bhaji Paneer Dosa
Pav Bhaji Cheese Paneer Dosa
Spring Vegetable Dosa
Spring Paneer Vegetable Dosa
Spring Cheese Vegetable Dosa
Spring Paneer Cheese Vegetable Dosa
Sweet Corn Dosa
Sweet Corn Cheese Dosa
Sweet Corn Paneer Dosa
Sweet Corn Paneer Cheese Dosa
Sweet Corn Schezwan Dosa
Sweet Corn Schezwan Paneer Dosa
Sweet Corn Schezwan Cheese Dosa
Sweet Corn Schezwan Paneer Cheese Dosa
Sweet Corn Mushroom Dosa
Sweet Corn Mushroom Paneer Dosa
Sweet Corn Mushroom Cheese Dosa
Sweet Corn Mushroom Paneer Cheese Dosa
Mushroom Dosa
Mushroom Cheese Dosa
Mushroom Paneer Dosa
Mushroom Paneer Cheese Dosa
Schezwan Mushroom Dosa
Schezwan Mushroom Paneer Dosa
Schezwan Mushroom Cheese Dosa
Schezwan Corn Mushroom Paneer Cheese Dosa
Paneer Chilli Dosa
Paneer Chilli Cheese Dosa
Mushroom Chilli Dosa
Mushroom Chilli Cheese Dosa
Mushroom Chilli Paneer Dosa
Mushroom Chilli Paneer Cheese Dosa
Sada Uttappam Dosa
Sada Uttappam Cheese Dosa
Sada Uttappam Paneer Dosa
Sada Uttappam Paneer Cheese Dosa
Onion Uttappam Dosa
Onion Uttappam Cheese Dosa
Onion Uttappam Paneer Dosa
Onion Uttappam Paneer Cheese Dosa
Masala Uttappam Dosa
Masala Uttappam Cheese Dosa
Masala Uttappam Paneer Dosa
Masala Uttappam Paneer Cheese Dosa
Mysore Uttappam Dosa
Mysore Uttappam Cheese Dosa
Mysore Uttappam Paneer Dosa
Mysore Uttappam Paneer Cheese Dosa
Mixed Uttappam Dosa
Mixed Uttappam Cheese Dosa
Mixed Uttappam Paneer Dosa
Mixed Uttappam Paneer Cheese Dosa

Comments are not for extended discussion; this conversation has been moved to chat.

This is code golf and not fastest gun. You should give the challenge some time (a week or so) before accepting an answer. But you can always change the accepted answer.

Python 2, 503 496 487 485 479 476 bytes
for l in[a+'86'[i<2:1+i%2][::2*('v'in a)-1]+b for i in(0,1,2,3)for a,b in[l.split('~')for l in('~11~'[i<2::2]+'0|Spring ~Vegetable |73~|13~|03~|:3~|Mixed 3~|~7|~27|~17|;4~|;42~|;45~|~Tomato 1|~21|~Chutney |2'+'45~|~20|~:0|~0|Jain ~|Pav Bhaji ~|5~|59~|'[i<3:]+'<~~<'[i%2::2]).split('|')]]+['682:0','69','698']:
 for i in range(13):l=l.replace(chr(48+i),'Masala Onion Schezwan Uttappam Corn Mushroom Paneer Sada Cheese Chilli Mysore Sweet Kerala'.split()[i]+' ')
 print l+'Dosa'

Try it online!
Every dosa is of the form a [Paneer, Cheese] b Dosa
Each dosa is then encoded in a list of tuples of (a,b). There are many dosa where a or b is empty.
For each of these tuples, every combination of Paneerand Cheese is added in between them.

.. '86'[i<2:1+i%2] .. for i in(0,1,2,3) ..

The few special cases which are slightly different are:

Kerala Dosa, Kerala Cheese Dosa vs Paneer Kerala Dosa, Paneer Cheese Kerala Dosa

Kerala is moved from a to b if we have Paneer
.. '<~~<'[i%2::2] .. which gives ['Kerala',''] or ['','Kerala']

Schezwan Corn Mushroom Paneer Cheese Dosa

Corn is inserted if we have Paneer Cheese
.. '4..'[i<3:] ..

Onion Masala Dosa, Onion Paneer Masala Dosa vs Cheese Onion Masala Dosa, Paneer Cheese Onion Masala Dosa

Onion is moved from a to b if we have Cheese
.. '~11~'[i<2::2] .., similar to Kerala above

Pav Bhaji Cheese Paneer Dosa

Paneer and Cheese are swapped if a is Pav Bhaji
.. '86'[i<2:1+i%2][::2*('v'in a)-1] ..

Paneer Cheese Schezwan Mysore Masala,Paneer Chilli,Paneer Chilli Cheese

These are too different to account for, and are just added to the list at the end.
.. +['682:0','69','698']

At the end, the numbers are replaced with the correct words:
0123456789:;< -> Masala Onion Schezwan Uttappam Corn Mushroom Paneer Sada Cheese Chilli Mysore Sweet Kerala

Retina 0.8.2, 339 bytes

19¶149¶169¶1Chutney ¶1Tomato 6¶146¶Jain 1¶13¶163¶143¶183¶/-483¶;0¶/0;¶Pav Bhaji 1¶Spring 1Vegetable ¶71¶741¶751¶51¶450¶45/¶4Corn 5/-¶/:0¶5:1¶92¶62¶32¶82¶Mixed 2
%(`$
Dosa
2
Uttappam 1
1
0$'¶$`/0
0
$%'¶$%`-
/63
6/3
i /-
i -/
/
Paneer
-
Cheese
;
Kerala
:
Chilli
9
Sada
8
Mysore
7
Sweet Corn
6
Onion
5
Mushroom
4
Schezwan
3
Masala

Try it online! This was 299 bytes before I discovered the edge cases...

Python 2, 436 bytes
00000000: 2363 6f64 696e 673a 3433 370a 696d 706f  #coding:437.impo
00000010: 7274 207a 6c69 620a 7072 696e 7420 7a6c  rt zlib.print zl
00000020: 6962 2e64 6563 6f6d 7072 6573 7328 2278  ib.decompress("x
00000030: da8d 554b 72c3 200c ddf7 14be 9a92 6862  ..UKr. .......hb
00000040: 52db 780c 499a 9ebe ed04 1309 3d91 eeec  R.x.I.......=...
00000050: f705 e1c1 894e 349c 62a2 8fe3 c89c 7848  .....N4.b.....xH
00000060: 1558 6961 de2c 6084 e917 f9be d35c 22a0  .Xia.,`......\".
00000070: 5d63 993d d565 7c6b 5c42 0425 2d5c 5c72  ]c.=.e|k\B.%-\\r
00000080: 1cd8 311d c76b 5ef8 a182 1556 ed08 b3f2  ..1..k^....V....
00000090: 1c67 cab1 d4c8 504b 9414 9770 8d75 44b6  .g....PK...p.uD.
000000a0: 0551 ede4 dd26 a4b8 5090 4f45 f902 4a82  .Q...&..P.OE..J.
000000b0: 01a4 70a6 4493 3e3b 0915 0780 80f8 b934  ..p.D.>;.......4
000000c0: 8b80 1075 e27e bae5 eb1c 401a e4da 09fb  ...u.~....@.....
000000d0: 6550 323f 52dc f04c 2cb3 cfc4 f5fc 57f0  eP2?R..L,.....W.
000000e0: 5a8a 557e f2d6 3ecb 032d 4152 a5b3 3573  Z.U~..>..-AR..5s
000000f0: 1b0e 235d 42fb aa13 7754 7e50 462b c9b4  ..#]B...wT~PF+..
00000100: 6e61 390f 373e 73a6 c3c4 5c6e 2d42 4c96  na9.7>s...\n-BL.
00000110: b0ae d3d1 dc99 f370 8cdb 62de e56e 04ac  .......p..b..n..
00000120: 566c 60c7 548f c625 9cd8 cabf 0bee f7cf  Vl`.T..%........
00000130: d734 6e31 ce3e e1f4 57fe 5d30 ba25 5429  .4n1.>..W.]0.%T)
00000140: 4c82 f5bd ccd7 37ae 7764 60b5 1fc3 c2c8  L.....7.wd`.....
00000150: b71b aa50 98a6 8020 b835 296f c19e 018e  ...P... .5)o....
00000160: 4473 6a1b 7f7f c06b ceb4 ae34 23c8 17ab  Dsj....k...4#...
00000170: 5921 465a 9fb7 ab2e 6ab0 8e5c 5661 5c6e  Y!FZ....j..\Va\n
00000180: fc67 7459 0bf6 0c6a 8698 53f6 e7c5 d9f4  .gtY...j..S.....
00000190: 3560 cfa0 fa30 a7ec e18b 4f6d 9dc6 3a72  5`...0....Om..:r
000001a0: 5506 2961 fe01 a6fe babb 2229 2e74 6974  U.)a......").tit
000001b0: 6c65 2829                                le()

Decompresses the string sada dosa\ncheese sada dosa\n…\n, and prints the result in title case.
Here is a Bash script that creates the program, prints its size and hexdump, and runs it.

05AB1E, 380 bytes
“³ŽÞÄæžŽ¹ÕÂŸÊÃÅ¦«“ð.•.ÚÜāÚÕuƒÚ·@â¥αmæ©½â…]M<.žk¦L0ηβ½ζ‰I°¸6þÈÑÈ)º#θ›34ù±q
œƒé•J™#
•yÊ£‰RÒ‡¨ÃιUÄŽn¾₅&p’ûüL1Ç*¶‡A¶„Ωðw#õqλ₆µŸÜ∊∊îà½Í*üÞ–´YΛæz…ć<þ‹Ž¡‡wBćèú₃Pjæ
†Oò;ÊāxµÏŒSv>H£Yœ<нΘ—[é”B‹āÕ×r₁t‡ù@l4ÐθÃ-R¨„“gt–å¶
∍»´₂*N§¨н∊í6ζ`pzÈ’v,q/äwájιìÆ¤”G₅Qαbbi'M?–’fт¥V2ÍÓ‡Žý+2≠Sf)A—+7-ù¯>v:ÍµK‘?˜6·Å₂!1 ćæQ1|iт†Ä"тë₄æ~…àÉÃùpû›ã~[и/±ÌðQÔāoĆ¹β«"CÜŽ›0∊/pâŒlλMÃ”Σ»<ˆŸcÎ‘€øPΛʒ=Ā5æVŽĆæ•23B'M¡€S22öè»

Try it online!

JavaScript (Node.js), 602 bytes
thanks for @Shaggy for updating according to new menu and usage of base 36 + array split :)

_=>`0
10
20
210
30
130
230
2130
40
140
240
2140
5
15
25
215
64
164
264
2164
34
134
234
2134
7
71
72
721
8
18
28
218
48
428
148
2148
38
138
238
2138
98
298
198
2198
21398
a
a1
2a
21a
b
b1
b2
b12
cd
c2d
c1d
c21d
f
f1
f2
f21
f3
f32
f31
f321
fg
fg2
fg1
fg21
g
g1
g2
g21
3g
3g2
3g1
3eg21
2h
2h1
gh
gh1
gh2
gh21
0i
0i1
0i2
0i21
4i
4i1
4i2
4i21
8i
8i1
8i2
8i21
9i
9i1
9i2
9i21
ji
ji1
ji2
ji21`.replace(/.|$/mg,x=>x?`Sada,Cheese,Paneer,Schezwan,Onion,Chutney,Tomato,Jain,Masala,Mysore,Kerala,Pav Bhaji,Spring,Vegetable,${c=`Corn`},Sweet ${c},Mushroom,Chilli,Uttappam,Mixed`.split`,`[parseInt(x,20)]+` `:`Dosa`)

Try it online!

o="Uttappam", "Mixed "+o <- that's clever, didn;t know you could do this

690 bytes

629 bytes

or 577 bytes with RegPack.

614 bytes

602 bytes - tempted to post it myself at this rate!

@Shaggy sorry, i was doing another challenge and was meant to update afterwards. thank you very much :)

Sorry, @DanielIndie, didn't mean to sound impatient above; was merely debating whether it had become sufficiently different from your original solution to warrant posting it myself.

Deadfish~, 19533 bytes
{{i}dd}iiic{i}iiiiciiicdddc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}dddc{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}ic{i}iiiiciiicdddc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iiiii}ic{i}iiiiciiicdddc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}ic{i}iiiiciiicdddc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiiii}ic{i}iiiiciiicdddc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}dddc{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}ic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiiii}ic{i}iiiiciiicdddc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iiiii}ic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiiii}ic{i}iiiiciiicdddc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}ic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiiii}ic{i}iiiiciiicdddc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dc{iii}icdddddciiiiiicdc{{d}ii}iic{iiiii}ic{i}iiiiciiicdddc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}dddc{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}dddc{iii}icdddddciiiiiicdc{{d}ii}iic{iiiii}ic{i}iiiiciiicdddc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iiiii}dddc{iii}icdddddciiiiiicdc{{d}ii}iic{iiiii}ic{i}iiiiciiicdddc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}dddc{iii}icdddddciiiiiicdc{{d}ii}iic{iiiii}ic{i}iiiiciiicdddc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}dddc{iiii}dddc{i}iiicdcddddddc{d}ic{ii}c{{d}i}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}dddc{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiic{iiii}dddc{i}iiicdcddddddc{d}ic{ii}c{{d}i}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddc{i}iiicdcddddddc{d}ic{ii}c{{d}i}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiic{iiii}dddc{i}iiicdcddddddc{d}ic{ii}c{{d}i}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiiic{iii}dddcddc{d}ddc{ii}dcdddddc{{d}ii}ic{iiiii}dddc{iii}icdddddciiiiiicdc{{d}ii}iic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}dddc{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}iic{iii}dddcddc{d}ddc{ii}dcdddddc{{d}ii}ic{iiiii}dddc{iii}icdddddciiiiiicdc{{d}ii}iic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iiiii}iic{iii}dddcddc{d}ddc{ii}dcdddddc{{d}ii}ic{iiiii}dddc{iii}icdddddciiiiiicdc{{d}ii}iic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}iic{iii}dddcddc{d}ddc{ii}dcdddddc{{d}ii}ic{iiiii}dddc{iii}icdddddciiiiiicdc{{d}ii}iic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiiii}dddc{iii}icdddddciiiiiicdc{{d}ii}iic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}dddc{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}ic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiiii}dddc{iii}icdddddciiiiiicdc{{d}ii}iic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iiiii}ic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiiii}dddc{iii}icdddddciiiiiicdc{{d}ii}iic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}ic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiiii}dddc{iii}icdddddciiiiiicdc{{d}ii}iic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}iiiic{ii}iiic{i}ddciiiiic{{d}ii}iic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}iiiic{ii}iiic{i}ddciiiiic{{d}ii}iic{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}iiiic{ii}iiic{i}ddciiiiic{{d}ii}iic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}iiiic{ii}iiic{i}ddciiiiic{{d}ii}iic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}dddc{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dc{iii}icdddddciiiiiicdc{{d}ii}iic{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dc{iii}icdddddciiiiiicdc{{d}ii}iic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}dddc{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}dddc{iii}icdddddciiiiiicdc{{d}ii}iic{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}dddc{iii}icdddddciiiiiicdc{{d}ii}iic{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}dddc{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}ic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iiiii}ic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}ic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iiii}iiiicddddddcddddciiic{d}dddc{{d}iii}ic{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iiii}iiiiic{iiii}iiiicddddddcddddciiic{d}dddc{{d}iii}ic{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}dddc{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiii}iiiiic{iiii}iiiicddddddcddddciiic{d}dddc{{d}iii}ic{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiii}iiiiic{iiii}iiiicddddddcddddciiic{d}dddc{{d}iii}ic{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}ic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiii}iiiiic{iiii}iiiicddddddcddddciiic{d}dddc{{d}iii}ic{iiii}iiiiic{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}iiiiic{ii}iiiiiic{i}iiic{dd}iiic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{iiiiii}iiiiic{ii}iiiiiic{i}iiic{dd}iiic{i}ic{d}dc{dddddd}dddddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iiii}iiic{ii}iiiiiic{i}iiic{dd}iiic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiii}iiic{ii}iiiiiic{i}iiic{dd}iiic{i}ic{d}dc{dddddd}dddddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{ii}ic{{d}ii}ddddddc{iii}iiiic{iiii}ddc{d}iiic{i}dcdc{{d}iii}dddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{ii}ic{{d}ii}ddddddc{iii}iiiic{iiii}ddc{d}iiic{i}dcdc{{d}iii}dddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{ii}ic{{d}ii}ddddddc{iii}iiiic{iiii}ddc{d}iiic{i}dcdc{{d}iii}dddc{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{ii}ic{{d}ii}ddddddc{iii}iiiic{iiii}ddc{d}iiic{i}dcdc{{d}iii}dddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}dciic{d}iciiiiic{d}iiic{{d}iii}dc{iiiii}iiiic{i}iiiiiciicddc{i}iiiiic{dd}icic{i}c{d}iiic{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}dciic{d}iciiiiic{d}iiic{{d}iii}dc{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iiiii}iiiic{i}iiiiiciicddc{i}iiiiic{dd}icic{i}c{d}iiic{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}dciic{d}iciiiiic{d}iiic{{d}iii}dc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}iiiic{i}iiiiiciicddc{i}iiiiic{dd}icic{i}c{d}iiic{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}dciic{d}iciiiiic{d}iiic{{d}iii}dc{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iiiii}iiiic{i}iiiiiciicddc{i}iiiiic{dd}icic{i}c{d}iiic{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}iiiiiic{dd}iicc{i}iiiiic{{d}ii}ddddc{iii}iiiiic{iiii}iiiiciiicddddc{{d}ii}iic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}iiiiiic{dd}iicc{i}iiiiic{{d}ii}ddddc{iii}iiiiic{iiii}iiiiciiicddddc{{d}ii}iic{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}iiiiiic{dd}iicc{i}iiiiic{{d}ii}ddddc{iii}iiiiic{iiii}iiiiciiicddddc{{d}ii}iic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}iiiiiic{dd}iicc{i}iiiiic{{d}ii}ddddc{iii}iiiiic{iiii}iiiiciiicddddc{{d}ii}iic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}iiiiiic{dd}iicc{i}iiiiic{{d}ii}ddddc{iii}iiiiic{iiii}iiiiciiicddddc{{d}ii}iic{iiiii}ic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}iiiiiic{dd}iicc{i}iiiiic{{d}ii}ddddc{iii}iiiiic{iiii}iiiiciiicddddc{{d}ii}iic{iiiii}ic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}iiiiiic{dd}iicc{i}iiiiic{{d}ii}ddddc{iii}iiiiic{iiii}iiiiciiicddddc{{d}ii}iic{iiiii}ic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}iiiiiic{dd}iicc{i}iiiiic{{d}ii}ddddc{iii}iiiiic{iiii}iiiiciiicddddc{{d}ii}iic{iiiii}ic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}iiiiiic{dd}iicc{i}iiiiic{{d}ii}ddddc{iii}iiiiic{iiii}iiiiciiicddddc{{d}ii}iic{iiii}iiiiic{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}iiiiiic{dd}iicc{i}iiiiic{{d}ii}ddddc{iii}iiiiic{iiii}iiiiciiicddddc{{d}ii}iic{iiii}iiiiic{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}iiiiiic{dd}iicc{i}iiiiic{{d}ii}ddddc{iii}iiiiic{iiii}iiiiciiicddddc{{d}ii}iic{iiii}iiiiic{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{iii}iiiiiic{dd}iicc{i}iiiiic{{d}ii}ddddc{iii}iiiiic{iiii}iiiiciiicddddc{{d}ii}iic{iiii}iiiiic{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiii}iiiiic{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiii}iiiiic{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iiii}iiiiic{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{i}iiiiiiciiiiicdddc{ii}icdddc{dd}ddc{i}iiic{{d}ii}iic{iii}iiiiic{iiii}iiiiciiicddddc{{d}ii}iic{iiii}iiiiic{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddciciiiccdddc{{d}iii}dddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}c{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddciciiiccdddc{{d}iii}dddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iii}iiiiic{iiii}dddciciiiccdddc{{d}iii}dddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iii}iiiiic{iiii}dddciciiiccdddc{{d}iii}dddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iii}iiiiic{iiii}dddciciiiccdddc{{d}iii}dddc{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iiii}cddc{d}dc{i}cdddccddc{{d}ii}iiic{iii}iiiiic{iiii}dddciciiiccdddc{{d}iii}dddc{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{i}iiiiciiicdddc{dddddd}dddddc{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{i}iiiiciiicdddc{dddddd}dddddc{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{i}iiiiciiicdddc{dddddd}dddddc{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}iiic{i}iiiiciiicdddc{dddddd}dddddc{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dc{iii}icdddddciiiiiicdc{{d}ii}iic{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dc{iii}icdddddciiiiiicdc{{d}ii}iic{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dc{iii}icdddddciiiiiicdc{{d}ii}iic{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dc{iii}icdddddciiiiiicdc{{d}ii}iic{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{ii}c{ii}ddc{dd}iic{i}ic{d}dc{dddddd}dddddc{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iiii}iiiicddddddcddddciiic{d}dddc{{d}iii}ic{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iiii}iiiicddddddcddddciiic{d}dddc{{d}iii}ic{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iiii}iiiicddddddcddddciiic{d}dddc{{d}iii}ic{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iiii}iiiicddddddcddddciiic{d}dddc{{d}iii}ic{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iii}ddc{i}iiiiic{dd}icdc{{d}iii}iic{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iii}ddc{i}iiiiic{dd}icdc{{d}iii}iic{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iii}ddc{i}iiiiic{dd}icdc{{d}iii}iic{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic{{i}ddd}dddc{iii}ddc{i}iiiiic{dd}icdc{{d}iii}iic{iiiii}iiic{iii}icc{dd}ic{i}iiiiicc{d}dddddc{i}iic{{d}ii}iiic{iiiii}ddc{ii}dddc{i}iiic{d}icc{i}iiic{{d}ii}ddc{iii}iiiiic{iiii}dddcdddcc{i}iiiic{d}ddddc{{d}iii}ic{iii}iiiiiic{iiii}iiiciiiic{dd}iic{{d}i}iiic

///, 540 bytes
/=/0\/\///;/-=`/<21//./5=,/3=>/2=</9=:/1=~/ \/\///0/Dosa
//1/Cheese~2/Paneer~3/Sada~4/Schezwan~5/Onion~6/Chutney~7/Tomato~8/Jain~9/Masala~!/Mysore~@/Kerala~#/Pav Bhaji~$/Spring~%/Vegetable~*/Corn~^/Sweet *//&/Mushroom~|/Chilli~-/Uttappam~_/Mixed /,1,2,21,4,14,24,214,5,15,25,215,6016026021607.17.27.217.4.14.24.214.808:8>82:<1<2`<5<52<15`5<4<14<24`4<!<2!<1!`!`4!<@0@:2@021@0#0#:#>#1>$%0$2%0$1%0$21%0^0^:^>^2:^40^4>^4:^42:^&0^&>^&:^&2:&0&:&>&2:4&04&>4&:4*&2:2|02|:&|0&|:&|>&|2:3;3-:3->3-2:5;5-:5->5-2:9;9-:9->9-2:!;!-:!->!-2:_;_-:_->_-21Dosa

Try it online!
Not the most amazing compression but still.

PHP, 425 421 bytes
beating Python again. happy.
foreach([_10,_8,_2,"_Chutney ","_Tomato 2",_82,"Jain ",_3,_23,_83,_63,"_Kerala ","Pav Bhaji ","Spring _Vegetable ",7,78,75,5,85,"5X ",100,20,30,60,"Mixed 0"]as$i=>$t){[$a,$b]=explode(_,$t);echo strtr($a.($c=$b."9$a")."1${c}4$c".($i-12?41:14).$b.($i-10?$i-18?9:"98Corn 54194X 94X 19":9418639),["Uttappam ","Cheese ","Onion ","Masala ","Paneer ","Mushroom ","Mysore ","Sweet Corn ","Schezwan ","Dosa
","Sada ",X=>Chilli]);}

Run with -nr or try it online.

Ruby, 448 bytes
00000000  72 65 71 75 69 72 65 20  27 7a 6c 69 62 27 0a 70  |require 'zlib'.p|
00000010  75 74 73 20 5a 6c 69 62  3a 3a 49 6e 66 6c 61 74  |uts Zlib::Inflat|
00000020  65 2e 69 6e 66 6c 61 74  65 28 44 41 54 41 2e 72  |e.inflate(DATA.r|
00000030  65 61 64 29 0a 5f 5f 45  4e 44 5f 5f 0a 78 da 8d  |ead).__END__.x..|
00000040  55 cd 4e c3 30 0c be f3  14 7d 16 c6 09 34 81 54  |U.N.0....}...4.T|
00000050  e0 6e 98 b5 06 75 cd d4  76 1b e3 e9 11 5a 9a d9  |.n...u..v....Z..|
00000060  f1 e7 8c 5b fb fd 26 4e  95 b6 b4 a1 e6 21 4e 74  |...[..&N.....!Nt|
00000070  b7 ea 98 27 6e da 0c bc  d0 c0 3c 5a c0 08 db cf  |...'n.....<Z....|
00000080  8e 7f 4e 34 08 68 d1 58  66 49 75 19 df fa 3c 84  |..N4.h.XfIu...<.|
00000090  08 4a 4a 38 e5 38 b0 63  5a 75 87 79 e0 b3 0a 56  |.JJ8.8.cZu.y...V|
000000a0  58 b6 23 cc ca 5f e3 8e  e6 98 6a 64 a8 25 52 8a  |X.#.._....jd.%R.|
000000b0  4b b8 c6 3c 22 db 82 a8  72 f2 6e 13 52 3c 52 90  |K..<"...r.n.R<R.|
000000c0  4f 49 79 05 52 82 01 a4  70 4d 13 f5 fa ec 24 94  |OIy.R...pM....$.|
000000d0  1c 00 02 e2 cb d2 2c 02  42 d4 89 fb e9 96 cf 73  |......,.B......s|
000000e0  00 69 90 2b 27 ec 97 41  c9 fa 3c c5 11 cf c4 32  |.i.+'..A..<....2|
000000f0  cb 4c 5c cf 7f 05 d7 a5  58 e5 13 8f e5 b3 3c d0  |.L\.....X.....<.|
00000100  14 24 55 3a 5b 33 c7 e6  be a3 af 50 be ea c4 05  |.$U:[3.....P....|
00000110  95 1f 94 d1 4a b2 dd 8f  61 d8 36 ef bc e5 99 3e  |....J...a.6....>|
00000120  7a 56 68 12 62 32 85 55  9d 8e e6 c4 3c 37 ab 38  |zVh.b2.U....<7.8|
00000130  0e e6 5d ee 46 c0 6a c5  06 76 4c f9 68 5c c2 89  |..].F.j..vL.h\..|
00000140  cd fc ad e0 7a ff fa 30  75 63 8c 3b 9f 70 fa 33  |....z..0uc.;.p.3|
00000150  7f 2b 18 dd 12 aa 14 26  c1 fa 5a e6 f5 1b d7 3b  |.+.....&..Z....;|
00000160  32 b0 da 8f 61 61 e4 cd  0d 65 28 f4 7d 40 10 dc  |2...aa...e(.}@..|
00000170  9a 94 97 60 cd 00 47 a2  39 b5 8d bf 3f e0 db 3c  |...`..G.9...?..<|
00000180  d3 7e 4f 3b 04 f9 62 35  2b c4 48 eb e5 76 d5 45  |.~O;..b5+.H..v.E|
00000190  05 56 91 cb 2a 4c 81 ff  8c 2e 2b c1 9a 41 cd 10  |.V..*L....+..A..|
000001a0  73 ca 7e b9 38 8b be 02  ac 19 54 1f e6 94 3d 7c  |s.~.8.....T...=||
000001b0  f3 a6 ac d3 58 45 ae ca  20 25 cc bf fa c0 88 fb  |....XE.. %......|


text:
Integer logarithms
Given integers N , P > 1 , find the largest integer M such that P ^ M ≤ N.
I/O:
Input is given as 2 integers N and P. The output will be the integer M.
Examples:
4, 5 -> 0
33, 5 -> 2
40, 20 -> 1
242, 3 -> 4
243, 3 -> 5
400, 2 -> 8
1000, 10 -> 3

Notes:
The input will always be valid, i.e. it will always be integers greater than 1.
Credits:
Credit for the name goes to @cairdcoinheringaahing. The last 3 examples are by @Nitrodon and credit for improving the description goes to @Giuseppe.

I know we (the PPCG community) can seem to be overly nit-picky about really small stuff, but comments like mine are really intended, in good faith, to make the challenge better! Now that that's been resolved, I have happily up-voted, and deleted my previous comments.

That's another reason why we suggest posting challenges into The Sandbox first, so that you can receive helpful feedback, post a great challenge, and get lots of high-quality answers, with much less fuss (like close- and down- votes). :)

You can always post into the general PPCG Chatroom asking for feedback on your sandbox challenges to get them a bit more attention.

Suggested test cases: one where P ^ M = N, and one where M = 0 (if you don't plan to exclude the latter case).

@Nitrodon : Suggested values ?

I've edited the title to describe the challenge more - feel free to make your own changes

Can we take input as a list of integers? [n,p] instead of n,p

So I realized I could shave off 5 bytes with reversed order on input -see my Mathematica answer, which begs the question, is the order strict?

Didnt't you mean in the IO section: ... while output will be integer M?

Almost all of the current answers based on floating-point math produce wrong results even for simple cases like (1000, 10) because of rounding error, so I added another test case.

**Meta post** about this challenge.

@Giuseppe : Please don't delete comments. Now I have no idea what you're talking about. Deleting comments makes responses completely contextless and usually meaningless.

@MPW all the responses were deleted, and the suggestions I made were edited into the post, so they were no longer relevant.

Brain-Flak, 74 bytes
(({}<>)[()])({()<(({})<({([{}]()({}))([{}]({}))}{})>){<>({}[()])}{}>}[()])

Try it online!
This uses the same concept as the standard Brain-Flak positive integer division algorithm.
# Push P and P-1 on other stack
(({}<>)[()])

# Count iterations until N reaches zero:
({()<

  # While keeping the current value (P-1)*(P^M) on the stack:
  (({})<

    # Multiply it by P for the next iteration
    ({([{}]()({}))([{}]({}))}{})

  >)

  # Subtract 1 from N and this (P-1)*(P^M) until one of these is zero
  {<>({}[()])}{}

# If (P-1)*(P^M) became zero, there is a nonzero value below it on the stack
>}

# Subtract 1 from number of iterations
[()])

JavaScript (ES6), 22 bytes
Saved 8 bytes thanks to @Neil
Takes input in currying syntax (p)(n).
p=>g=n=>p<=n&&1+g(n/p)

Try it online!

Excel, 18 bytes
=TRUNC(LOG(A1,A2))

Takes input "n" at A1, and input "p" at A2.

I think you can use INT function instead of TRUNC to save 2 bytes.

Jelly, 3 bytes
bḊL

This doesn't use floating-point arithmetic, so there are no precision issues.
Try it online!
How it works
bḊL  Main link. Left argument: n. Right argument: p

b    Convert n to base p.
 Ḋ   Dequeue; remove the first base-p digit.
  L  Take the length.

R, 25 bytes
function(p,n)log(p,n)%/%1

Try it online!
Take the log of P base N and do integer division with 1, as it's shorter than floor(). This suffers a bit from numerical precision, so I present the below answer as well, which should not, apart from possibly integer overflow.
R, 31 bytes
function(p,n)(x=p:0)[n^x<=p][1]

Try it online!

I don't know how strict the challenge requires us to be on rounding error but for example, f(243,3) is equal to 4 when it probably is required to be 5.

@JDL that's a fair point; I believe a perfectly precise answer would be ~31 bytes.

I think you can replace p by p+.1 in the 25 byte answer and you will still be okay, for 28 bytes

Another 28 byte solution without numerical precision issues.

C (gcc) + -lm, 24 bytes
f(n,m){n=log(n)/log(m);}

Try it online!

I know about long long but what is bytes bytes? :P

Also flags don't add to your byte count anymore, so I edited to reflect this.

Doesn't work for (1000, 10) because of rounding error.

f(n,m){n=(float)log(n)/log(m);} seems to work @31 bytes

Retina 0.8.2, 35 bytes
.+
$*
+r`1*(\2)+¶(1+)$
#$#1$*1¶$2
#

Try it online! Explanation:
.+
$*

Convert the arguments to unary.
+r`1*(\2)+¶(1+)$
#$#1$*1¶$2

If the second argument divides the first, replace the first argument with a # plus the integer result, discarding the remainder. Repeat this until the first argument is less than the second.
#

Count the number of times the loop ran.

Japt, 8 bytes
@<Vp°X}a

Try it

This is really neat, I haven't really seen a good use for the function methods in Japt yet, this is a good example.

@Nit, it took me a good while to get to grips with them, too - only recently started figuring out uses for F.g() - but they're incredibly useful.

Haskell, 16 bytes
(floor.).logBase

Try it online!
Haskell was designed by mathematicians so it has a nice set of math-related functions in Prelude.

Doesn't work for (1000, 10) because of rounding error.

Haskell, 30 bytes
n!p=until((>n).(p^).(1+))(1+)0

Try it online!

Either until((>n).(p^))(1+)0-1 or until(\x->p^x*p>n)(1+)0 gets you down to 27 bytes.

Perl 6, 13 bytes
&floor∘&log

Try it online!
Concatenation composing log and floor, implicitly has 2 arguments because first function log expects 2. Result is a function.

For arguments 1000, 10 this returns 2.

@Sean: Huh, interesting precision issue there

Python 2, 39 bytes
lambda a,b:math.log(a,b)//1
import math

Try it online!

1000,10 as inputs gives 2 as output.

Japt, 5 bytes
ìV ÊÉ

Try it online!

8 bytes
N£MlXÃäz

Try it online!

Was about to post the same thing using ì instead of s as s will fail if V>36.

@Shaggy Good call on V>36.

JavaScript, 40 33 bytes
-3 bytes thanks to DanielIndie
Takes input in currying syntax.
a=>b=>(L=Math.log)(a)/L(b)+.001|0

Try it online!

29 bytes

28 bytes and maybe if you want curry method

@nwellnhof https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/R1i7J1k7Dx9Y3sSRDLyc/XVMjUVPfRyNJs8bgf3J@XnF@TipIWCNNw9DAwEATSGpqKigo6OsrGHOhypsAZY3AskBJQwxJkCxU0uI/AA

Doesn't work for (999, 10) (should output 2)

@Oliver The smallest problem I could find is 17179869183 (2^34-1) and 2, which should output 33 but instead outputs 34. In general, there exists a large enough n such that 2^n-1 and 2 produce the wrong output, for any number in place of .001

@HermanLauenstein I think I have a new workaround.

The toString solution only works for bases up to 36.

05AB1E, 6 bytes
Lm¹›_O

Try it online!

this just seems unfair to everyone else

@Floris Competitions are between submissions in each language not between languages right?

@user202729 yes and no. In my mind, in the end, "shortest code wins". But I noticed there was a 2-byte solution further down... These golf languages blow my mind.

@Floris "Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language."

@Floris Also... even Excel can do it in 2 builtins. Golfing languages can do this in 2 built-in too, just the builtin names are shorter. Nothing to surprise.

Emojicode, 49 48 bytes
ij➡➖i j 1

Try it online!

APL (Dyalog Unicode), 2 bytes
⌊⍟

Try it online!
Pretty straightforward.
⍟ Log
⌊ floor

Make dyadic to save a byte: ⌊⍟

I'm slightly ashamed you actually had to tell me that >.> thanks, though!

Pari/GP, 6 bytes
logint

(built-in added in version 2.7, Mar 2014.  Takes two arguments, with an optional third reference which, if present, is set to the base raised to the result)

@StewieGriffin logint(x,y) from both Pari/GP and Perl/ntheory give the correct results for the 7 examples currently shown, including '3' for 1000,10.

+1, but I would count this as 6 bytes.

You're not allowed to use hardcoded inputs, so this must be a function (eg. as a lambda or definition). However you can just use logint which is valid and counts 5 bytes less.

Ruby, 31 bytes
OK, so all those log-based approaches are prone to rounding errors, so here is another method that works with integers and is free of those issues:
->n,p{(0..n).find{|i|p**i>n}-1}

Try it online!
But going back to logarithms, although it is unclear up to what precision we must support the input, but I think this little trick would solve the rounding problem for all more or less "realistic" numbers:
Ruby, 29 bytes
->n,p{Math.log(n+0.1,p).to_i}

Try it online!

Python 2, 3, 46 bytes
-1 thanks to jonathan
def A(a,b,i=1):
 while b**i<=a:i+=1
 return~-i

Python 1, 47 bytes
def A(a,b,i=1):
 while b**i<=a:i=i+1
 return~-i

n~-i is one byte shorter than n i-1.

Also, please state your Python's version.

Will work in any version, won't it?

It will not work in Python 1.

JavaScript (Node.js), 22 bytes
m=>f=n=>n<m?0:f(n/m)+1

Try it online!
Curried recursive function. Use as g(P)(N). Less prone to floating-point errors than using Math.log, and (I believe) the code gives correct values as long as both inputs are safe integers (under 2**52).

Haskell, 35 34 bytes
n!p=last.fst$span((<=n).(p^))[0..]

Thanks @Laikoni for saving 1 byte
Try it online!

Pyth, 6 4 bytes
s.lF

Saved 2 bytes thanks to Mmenomic
Try it online
How it works
.l is logB(A)
To be honest, I have no idea how F works. But if it works, it works.
s truncates a float to an int to give us the highest integer for M.

1000,10 as inputs gives 2 as output

Another similar solution is /FlM

Husk, 8 7 4 bytes
Lt`B

Try it online!

J, 5 bytes
<.@^.

Try it online!

Wolfram Language (Mathematica) 15 10 Bytes
Floor@*Log

(requires reversed order on input)
Original submission
⌊#2~Log~#⌋&

⌊Log@##⌋& is one byte shorter

@Mathe172, that's one character shorter, but I count 13 bytes on that. The left floor and right floor count as 3 bytes each in UTF-8.

@StewieGriffin %[10,1000] gives 3. The inputs are treated as integers rather than machine numbers unless you put a decimal place after them.

Forth (gforth), 35 bytes
: f swap s>f flog s>f flog f/ f>s ;

Try it online!
Could save 5 bytes by swapping expected input parameters, but question specifies N must be first (an argument could be made that in a postfix language "First" means top-of-stack, but I'll stick to the letter of the rules for now)
Explanation
swap       \ swap the parameters to put N on top of the stack
s>f flog   \ move N to the floating-point stack and take the log(10) of N
s>f flog   \ move P to the floating-point stack and take the log(10) of P
f/         \ divide log10(N) by log10(P)
f>s        \ move the result back to the main (integer) stack, truncating in the process

Wonder, 9 bytes
|_.sS log

Example usage:
(|_.sS log)[1000 10]

Explanation
Verbose version:
floor . sS log

This is written pointfree style. sS passes list items as arguments to a function (in this case, log).

Gforth, 31 Bytes
SWAP S>F FLOG S>F FLOG F/ F>S .

Usage
242 3 SWAP S>F FLOG S>F FLOG F/ F>S . 4 OK

Try it online!
Explanation
Unfortunately FORTH uses a dedicated floating-point-stack. For that i have to SWAP (exchange) the input values so they get to the floating point stack in the right order. I also have to move the values to that stack with S>F. When moving the floating-point result back to integer (F>S) I have the benefit to get the truncation for free.
Shorter version
Stretching the requirements and provide the input in float-format and the right order, there is a shorter version with 24 bytes.
FLOG FSWAP FLOG F/ F>S .
3e0 242e0 FLOG FSWAP FLOG F/ F>S . 4 OK

Try it online!

Generally for CodeGolf answers, snippets are disallowed (unless otherwise indicated in the challenge). This answer should either be wrapped with a function (Word in Forth) : f .... ; or a converted to a  program that takes input using KEY or ACCEPT

@reffu What is a snippet? In my opinion a smal code part to show something, which, however, does nothing meaningful for itself. On the other hand, the code that I've provided does work without changes on "Try it online!".  Should we go meta?

In this particular case the code you posted will in fact throw a stack underflow unless you place the parameters before it. Code golf answers should generally be a self-contained program or function that produces the expected result if called later. If you follow the link to the meta post in my previous comment it explicitly mentions that the standard is for answers to be a program or a function, of which yours is neither. To fix it would only require another 4 bytes

C (gcc), 61 bytes
i(n,t,l,o,g){for(l=g=0;!g++;g=g>n)for(o=++l;o--;g*=t);g=--l;}

Try it online!

PowerShell 3,  44 38 Bytes
param($n,$p)for(;($n/=$p)-ge1){$z++}$z

Truncating to an int is too dang long in this language. However, looting the formula others are using bypasses this. Crossed-out 44 is still 44

x86(16/32 bit) opcode, 13 bytes
83 CB FF  31 DB  F7 F1  43  09 C0  75 F7  C3

Input EAX, ECX, output EBX
OR  EBX, -1
XOR EDX, EDX
DIV ECX
INC EBX
OR  EAX, EAX
JNZ $-7
RET

Although this is one of the shortest answers, it could do with at least some explanation (preferably a disassembly, so that mortals can see which registers are used, and which opcodes).

But 32 bit division not use edx? So edx it is not initialized to 0?

@RosLuP Fixed..

MATL, 5 bytes
:YAnq

Try it online!
Simple arbitrary base conversion to avoid using floating point math.

Ruby, 29 26 bytes
f=->n,p{n<p ?0:1+f[n/p,p]}

Try it online!

Pyth, 8 bytes
tf<Q^vzT

Test suite.
Explanation
tf<Q^vzT – Full program.
 f       – First positive integer T that satsfies:
   Q       – The first input
  <        – Is less than
     vz    – The second input
    ^  T   – Raised to the T-th power.
t        – Decrement the integer and output implicitly.

Intel 8087 FPU assembly, 38 bytes
Uses only the Intel 8087 math co-processor.
d9e8 df06 3c01 d9f1 d9e8 df06 3e01 d9f1 def9 9bd9
3e3e 0181 0e3e 0100 0c9b d92e 3e01 df1e 3c01

Unassembled:
; Integer logarithm
; input: integers N, P > 1 (mem16,mem16)
; output: N (mem16) largest integer such that P ^ M ≤ N
INTLOG  MACRO N,P
        FLD1        ; ST(1) = 1
        FILD N      ; ST = N
        FYL2X       ; ST = 1 * LOG2(N)
        FLD1        ; ST(1) = 1
        FILD P      ; ST = P
        FYL2X       ; ST = 1 * LOG2(P)
        FDIV        ; ST = LOG2(N) / LOG2(P)
        FWAIT       ; sync CPU/FPU
        FSTCW P     ; get the current CW register
        OR P, 0C00H ; set RC for floor rounding mode
        FWAIT       ; sync CPU/FPU
        FLDCW P     ; set the modified CW register
        FISTP N     ; N = FLOOR(ST)
        ENDM

Example IBM PC DOS test program:
    FINIT           ; reset 8087
    CALL INDEC      ; generic decimal input routine
    MOV  N, AX      ; first input into N
    CALL INDEC      ; generic decimal input routine
    MOV  P, AX      ; second input into P
    INTLOG N,P      ; calculate
    MOV  AX, N      ; result in N into AX for display
    CALL OUTDEC     ; generic decimal output routine

Tests:
A>INTDEC.COM
: 4
: 5
0
A>INTDEC.COM
: 33
: 5
2
A>INTDEC.COM
: 40
: 20
1
A>INTDEC.COM
: 242
: 3
4
A>INTDEC.COM
: 243
: 3
5
A>INTDEC.COM
: 400
: 2
8
A>INTDEC.COM
: 1000
: 10
3

Note: 16 bytes of this code are just for putting the FPU into floor rounding mode.

Python 3 with mpmath, 52 bytes
import mpmath
def f(N,P):return int(mpmath.log(N,P))

Test it:
for N, P in zip([4, 33, 40, 242, 243, 400, 1000], [5, 5, 20, 3, 3, 2, 10]):
    print(f(N,P))

How I would really do it. The mpmath (included with SymPy) logarithm seems more accurate, even at default. I always love some arbitrary precision floating-point. I was really surprised that the standard methods led to such inaccuracies.

Keg, -hr,  19 bytes
¿&¿0{:^:'$Ë&:&≤|⑨};

Try it online!
Uses the same technique as the Pyth answer
Explained

Wren, 32 bytes
Log, log, floor.
Fn.new{|a,b|(a.log/b.log).floor}

Try it online!

Lua, 47 37 bytes
(N,P)return math.floor(math.log(N,P))

Try it online!
Thanks to @user9549915 for saving 10 bytes

PHP, 43 Bytes
Try it online!
Code
function f($p,$n){echo intval(log($p,$n));}

intval() truncates a float number, as for log($p,$n) the integer part of the result will always be the maximum positive integer that satisfies the inequation.
34 Bytes
If passing arguments to the script
Try it online
Code
<?=intval(log($argv[0],$argv[1]));

@FransiscoHahn : This is code-golf so you might wanna shorten your code ?

Ruby, 31 bytes
->n,p,d=0{n<p**(d+=1)?d-1:redo}

Try it online!
Curse you, floating point errors

Python 3, 40 39 bytes
-1 @Jonathan
g=lambda n,p,a=1:a*p<=n and-~g(n,p,a*p)

Try it online!

Don't you need the g= in order for this to work? My understanding has always been that unnamed functions are OK, except in cases like this where the function is referred to by name elsewhere (as in recursive functions).  So for example, (lambda n,p,a=1:a*p<=n and g(n,p,a*p)+1)(5, 5) will obviously produce an error, but instead I can do g=lambda n,p,a=1:a*p<=n and g(n,p,a*p)+1 and then call g(5,5).  [Unless maybe a new consensus has emerged about this...?]

@mathmandan - you are correct, my bad.  fixed.

expected 0, got False.  Okay....

@Jonathan, in a numeric context False has the value 0.

@RootTwo I know, it just looked funny to call that Okay.. You could have used {r:d} in your string formatting.

Can and g(...)+1 not be and-~g(...)?

PHP, 28 bytes
<?=log($argv[1],$argv[2])|0;

Try it online

saved 3 bytes : https://tio.run/##K8go@G9jb/s/Jz9dQyWxKL0s2jBWB8IwitWsMbD@//@/oYGBAZAAAA

That wouldn't be valid; the <?= is required.

Perl 6, 22 bytes
{(1,*×$^p...*>$^n)-2}

Try it online!
1, * × $^p ... * > $^n is a sequence that starts with 1, where each succeeding element is generated from the previous by multiplying by $^p (the second argument to the function), and continues up to the element * such that * is greater than $^n (the first argument to the function).  Subtracting two from this sequence coerces it to a number, specifically its length.  Two less than the length is the desired integer logarithm.

Tcl, 39 bytes
proc L n\ p {expr int(log($n)/log($p))}

Try it online!
Gives 4 for (243,3) as it is the integer truncation of 4.99999999999999...! The same happens when I tried other answers!

Darn rounding errors >:(

C (gcc), 41 31 bytes
Thanks to Kevin for his suggestion, which is reproduced below:
f(n,p,m){for(;n/=p;m++);n=m-2;}

Try it online!
Previous submission:
f(n,p){int m;for(m=0;n/=p;m++);return m;}

Try it online!
No library functions required.

I think setting m to a parameter saves a couple bytes. Try it online! -- truth be told, I was looking at "Tips for Golfing in C" and saw this; my C knowledge is minimal at best.

First I want to ask, why do you initialize int m; and only in the for-loop do m=0? You could have done int m=0;for(;... directly. In C however you can use some nice tricks, including the one stated (but incorrectly linked in the TIO I think) by @Giuseppe, as well as dropping the return like this: m;f(n,p){for(m=0;n/=p;m++);n=m;} Try it online 32 bytes

Actually, using ,m as parameter implicitly gives it the parameter-index as initial value (not sure if this is always the case, my C knowledge is limited). If it indeed is, f(n,p,m){for(;n/=p;m++);n=m-2;} can be used instead for 31 bytes. Try it online. Oh, and welcome to PPCG! :)

Java 8, 36 34 bytes (with floating point errors on one test case)
a->b->b+=Math.log(a)/Math.log(b)-b

-2 bytes thanks to @OlivierGrégoire.
Try it online.
Explanation:
Java only has Math.log(double val) as builtin, which is basically log10. For logn(val) you'll have to use Math.log(val)/Math.log(n).
So this is what the Math.log(a)/Math.log(b) does. The b+=...-b is used to cast the doubles of the Math.log to an integer, which is shorter than a->b->(int)(Math.log(a)/Math.log(b)) (thanks @OlivierGrégoire).

Java 10, 245 240 239 231 bytes
a->b->(int)(l(a)/l(b));double l(java.math.BigInteger v){int n=v.bitLength(),i=0,j=0;long t=1L<<52,M=t,m=0;for(;++i<54&&(j=n-i)>=0;M>>=1)m|=v.testBit(j)?M:0;return(n-1+Math.log((j>0&&v.testBit(j-1)?m+1:m)*1f/t)*1.4426950408889634);}

-5 bytes thanks to @ceilingcat.
Try it online.
Explanation:
To fix the floating point errors we'll have to use a BigInteger log. a->b->(int)(l(a)/l(b)) is basically the same as before (note that a and b are now java.math.BigInteger inputs instead of int, so the same b+=...-b won't work here.
The separated log-method for better precision I got from this Stackoverflow answer.
double l(java.math.BigInteger v){
  // Get the minimum number of bits necessary to hold this value
  int n=v.bitLength(),
  // Index integers
      i=0,j=0;
  // Calculate the double-precision fraction of this numbers; as if the
  // binary point was left of the most significant '1' bit.
  // (Get the most significant 53 bits and divide by 2^53)
  // mantissa is 53 bits (including hidden bit)
  long t=1L<<52,M=t,m=0;
  for(;++i<54&&(j=n-i)>=0;M>>=1)m|=v.testBit(j)?M:0;
  // Round up if next bit is 1.
  // Add the logarithm to the number of bits, and subtract 1 because the
  // number of bits is always higher than necessary for a number
  // (i.e. log2(v)<n for every `v`)
  return(n-1+Math.log((j>0&&v.testBit(j-1)?m+1:m)*1f/t)*1.4426950408889634);}
  // Magic number converts from base e to base 2 before adding. For other
  // bases, correct the result, NOT this number!

Suggest ++i<54&(j=n-i)>=0;M/=2 instead of ++i<54&&(j=n-i)>=0;M>>=1

dc, 30 bytes
sp0sm[dlplm1+dsm^!>M]dsMxlm1-p

Try it online!
No logs in dc means no FP errors... Also means doing the thing repeatedly and testing to see when we go over, which... is not very golfy.
Straightforward, but here's the gist: sp stores our p value in p; 0sm stores a zero in what will ultimately be our m value, m. Macro M duplicates what's left on the stack (n), loads p, loads m, spends a lot of bytes incrementing m (lm1+dsm), does the exponentiation ^ and tests if the result is less than or equal to n (left on stack). Keeps going so long as this is true, then loads m, subtracts 1, and prints it.

Haskell, 30 bytes
f n p=head[x|x<-[0..],p^x>n]-1

Should be no round-off errors

27 bytes - Try it online!

q, 42 bytes
{r::x;{$[r>=y xexp x;x;.z.s[x-1;y]]}[x;y]}

Gol><>, 7 bytes
IISLS(h

Can take the inputs seperated by a comma. (ex. [4,5], [6,8])
I'm pretty sure that this is the absolute smallest it can get..

Runic Enchantments, 13 bytes
i'LAi'LA,'fA@

Try it online!
Nothing fancy here. Reads an input and calls Log on it, repeats for the second input, divides, and floors. Runic is very permissive with typing, using implicit conversions where it makes sense to do so, with only a couple of explicit conversion operators (to-number, to-char, and dictionary-lookup).
Equivalent to (int)Math.Floor((double)Math.Log(a) / Math.Log(b))

Vyxal, 3 bytes
$•⌊

Try it Online!
$•⌊
$   # swap input
 •  # log
  ⌊ # floor

nroff, 95 bytes
It's stupid that I had to increment one more than expected, then decrement the value. I tried replacing initial value .nr M -1 and deleting decrementing part but the result went something very crazy (e.g. .F 4 5 returned -3 and .F 1000 10 returned 1526194161). How does nroff really represent numerical value!?
.de F
.nr t 1
.nr M 0
.while \\nt<=\\$1 \\{.nr t \\nt*\\$2
.nr M \\nM+1\\}
.nr M \\nM-1
\\nM
..

Attempt This Online!

Pyt, 7 bytes
Đ←⇹ř^≥Ʃ

Try it online!
Couldn't use built-in log function because of floating-point inaccuracies. Takes N, then P.
Đ              implicit input; Đuplicate
 ←             get input
  ⇹            swap top two on stack
   ř           řangify
    ^          raise to power element-wise
     ≥         is N greater than or equal to each element?
      Ʃ        Ʃum; implicit print

Thunno 2 L, 2 bytes
Bḣ

Attempt This Online!
Convert the second input to Base-first input, then remove the ḣead (first item). The L flag takes the length.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Bots playing a counting game
Introduction
A childhood game designed to help children learn to count in french in Canadian schools is played as follows:

Students go around the room counting up to 11
A number greater than 11 cannot be said
A student can say either 1, 2, or 3 numbers
If a student says the number 11 then they are removed from the next round and play begins again at 1
The game continues until there is 1 player remaining

Consider the simple example:
Player1 | Player2
01      |
02      |
03      |
        | 04
        | 05
        | 06
07      |
08      |
        | 09
10      |
        | 11
Player 1 wins

The rules

Design a program which takes in an integer greater than or equal to 2 and less than or equal to 99 (for formatting reasons) and outputs the game played by this number of bots
Play will begin with bot1 and increase to the highest number bot
Play will cycle back to the beginning when the final bot is reached
Bots will randomly output the next 1, 2, or 3 numbers UNLESS

Outputting 2 or 3 numbers will cause them to lose on that turn.

If the count is 8 when it reaches a bot, it should only decide between 9 and 10

Outputting 2 or 3 numbers will cause them to go over 11

Output numbers and bot numbers should be formatted  to take two characters (i.e. you can format numbers to be 01, _1, or whitespace, whatever makes you happy)
Each column should be 2 characters wide separated by | as well as a | at the beginning and ends of rows
Once a bot is out the remainder of their column should be filled by xx
When there is only one bot remaining he is the winner
The program will announce which bot was the winner in the form of Bot #N is the winner
This is code-golf so shortest byte count wins

Formatting examples
|01|02|03|
|01|  |  |
|02|  |  |
|03|  |  |
|  |04|  |
|  |  |05|
|  |  |06|
|07|  |  |
|  |08|  |
|  |09|  |
|  |10|  |
|  |  |11|
|01|  |xx|
|02|  |xx|
|03|  |xx|
|  |04|xx|
|  |05|xx|
|06|  |xx|
|  |07|xx|
|08|  |xx|
|  |09|xx|
|  |10|xx|
|11|  |xx|
Bot #2 is the winner

Option
The outputs can get long so you are permitted to output only the final number of the bots turn for example the above output becomes instead:
|01|02|03|
|03|  |  |
|  |04|  |
|  |  |06|
|07|  |  |
|  |10|  |
|  |  |11|
|03|  |xx|
|  |05|xx|
|06|  |xx|
|  |07|xx|
|08|  |xx|
|  |10|xx|
|11|  |xx|
Bot #2 is the winner

With 5 bots:
|01|02|03|04|05|
|01|  |  |  |  |
|  |04|  |  |  |
|  |  |05|  |  |
|  |  |  |07|  |
|  |  |  |  |10|
|11|  |  |  |  |
|xx|01|  |  |  |
|xx|  |03|  |  |
|xx|  |  |06|  |
|xx|  |  |  |09|
|xx|10|  |  |  |
|xx|  |11|  |  |
|xx|  |xx|02|  |
|xx|  |xx|  |03|
|xx|05|xx|  |  |
|xx|  |xx|07|  |
|xx|  |xx|  |08|
|xx|10|xx|  |  |
|xx|  |xx|11|  |
|xx|  |xx|xx|01|
|xx|03|xx|xx|  |
|xx|  |xx|xx|04|
|xx|07|xx|xx|  |
|xx|  |xx|xx|08|
|xx|10|xx|xx|  |
|xx|  |xx|xx|11|
Bot #2 is the winner

With 10 players:
|01|02|03|04|05|06|07|08|09|10|
|01|  |  |  |  |  |  |  |  |  |
|  |04|  |  |  |  |  |  |  |  |
|  |  |05|  |  |  |  |  |  |  |
|  |  |  |08|  |  |  |  |  |  |
|  |  |  |  |09|  |  |  |  |  |
|  |  |  |  |  |10|  |  |  |  |
|  |  |  |  |  |  |11|  |  |  |
|  |  |  |  |  |  |xx|02|  |  |
|  |  |  |  |  |  |xx|  |04|  |
|  |  |  |  |  |  |xx|  |  |07|
|09|  |  |  |  |  |xx|  |  |  |
|  |10|  |  |  |  |xx|  |  |  |
|  |  |11|  |  |  |xx|  |  |  |
|  |  |xx|01|  |  |xx|  |  |  |
|  |  |xx|  |02|  |xx|  |  |  |
|  |  |xx|  |  |03|xx|  |  |  |
|  |  |xx|  |  |  |xx|04|  |  |
|  |  |xx|  |  |  |xx|  |07|  |
|  |  |xx|  |  |  |xx|  |  |08|
|09|  |xx|  |  |  |xx|  |  |  |
|  |10|xx|  |  |  |xx|  |  |  |
|  |  |xx|11|  |  |xx|  |  |  |
|  |  |xx|xx|02|  |xx|  |  |  |
|  |  |xx|xx|  |03|xx|  |  |  |
|  |  |xx|xx|  |  |xx|05|  |  |
|  |  |xx|xx|  |  |xx|  |08|  |
|  |  |xx|xx|  |  |xx|  |  |09|
|10|  |xx|xx|  |  |xx|  |  |  |
|  |11|xx|xx|  |  |xx|  |  |  |
|  |xx|xx|xx|03|  |xx|  |  |  |
|  |xx|xx|xx|  |05|xx|  |  |  |
|  |xx|xx|xx|  |  |xx|08|  |  |
|  |xx|xx|xx|  |  |xx|  |10|  |
|  |xx|xx|xx|  |  |xx|  |  |11|
|01|xx|xx|xx|  |  |xx|  |  |xx|
|  |xx|xx|xx|03|  |xx|  |  |xx|
|  |xx|xx|xx|  |06|xx|  |  |xx|
|  |xx|xx|xx|  |  |xx|08|  |xx|
|  |xx|xx|xx|  |  |xx|  |09|xx|
|10|xx|xx|xx|  |  |xx|  |  |xx|
|  |xx|xx|xx|11|  |xx|  |  |xx|
|  |xx|xx|xx|xx|03|xx|  |  |xx|
|  |xx|xx|xx|xx|  |xx|05|  |xx|
|  |xx|xx|xx|xx|  |xx|  |06|xx|
|08|xx|xx|xx|xx|  |xx|  |  |xx|
|  |xx|xx|xx|xx|09|xx|  |  |xx|
|  |xx|xx|xx|xx|  |xx|10|  |xx|
|  |xx|xx|xx|xx|  |xx|  |11|xx|
|02|xx|xx|xx|xx|  |xx|  |xx|xx|
|  |xx|xx|xx|xx|05|xx|  |xx|xx|
|  |xx|xx|xx|xx|  |xx|08|xx|xx|
|09|xx|xx|xx|xx|  |xx|  |xx|xx|
|  |xx|xx|xx|xx|10|xx|  |xx|xx|
|  |xx|xx|xx|xx|  |xx|11|xx|xx|
|01|xx|xx|xx|xx|  |xx|xx|xx|xx|
|  |xx|xx|xx|xx|04|xx|xx|xx|xx|
|07|xx|xx|xx|xx|  |xx|xx|xx|xx|
|  |xx|xx|xx|xx|10|xx|xx|xx|xx|
|11|xx|xx|xx|xx|  |xx|xx|xx|xx|
Bot #6 is the winner

Comments are not for extended discussion; this conversation has been moved to chat.

JavaScript (Node.js), 269 245 240 233 232 231 bytes

thanks to @Kevin Cruijssen for reducing by 1 byte

N=>{for(S=d=[],D=n=i=0;D<N-1;){for(R=n>8?1:(n>7?2:3)*Math.random()+1|0;R--;)S+="|"+[...Array(N)].map((x,I)=>i^I?d[I]?"xx":"  ":++n>9?n:"0"+n).join`|`+`|
`
for(n>10&&(d[i]=++D,n=0);d[i=++i%N];);}return S+`Bot #${i+1} is the winner`}

Try it online!

You can save a byte by removing the new-line at )\nS+=.

Python 2, 295 291 290 bytes
from random import*
n=input()
r=range(n)
p=r[:]
b=[1]*n;s='%02d'
def P(l):print'|%s|'%'|'.join(l)
P(s%-~j for j in r)
x=0
while sum(b)>1:i=p.pop(0);g=choice(range(x+1,11)[:3]or[11]);P([2*'x '[b[j]],s%g][j==i]for j in r);x=g%11;b[i]=g<11;p+=[i]*b[i]
print'Bot #%d is the winner'%-~b.index(1)

Try it online!

-1 byte, thanks to Kevin Cruijssen

You can save a byte by making a variable for '%02d' which you are using twice.

No problem. I keep golfing just 1 or 2 bytes from your answers lol.. Just goes to show how well golfed your answers already are for my concise Python knowledge. ;)

C (clang), 288 283 282 266 bytes
f(n){int i,j,p[99]={},m,k,x;for(i=j=k=0;k<n;printf("|%02d",k++));for(puts("|"),m=n;x=i>7?10-i:3,i=x?clock()%x-~i:0,m>1;){for(k=~0;++k<n;printf(p[k]?"|xx":k-j?"|  ":"|%02d",i?i:11));puts("|"),!i&&m--*p[j]++;do j++,j%=n;while(p[j]);}printf("Bot #%d is the winner",j);}

Try it online!
Bots are 0 indexed.
Following will do 1-indexed for+2 bytes
f(n){int i,j,p[99]={},m,k,x;for(i=j=k=0;k<n;printf("|%02d",++k));for(puts("|"),m=n;x=i>7?10-i:3,i=x?clock()%x-~i:0,m>1;){for(k=~0;++k<n;printf(p[k]?"|xx":k-j?"|  ":"|%02d",i?i:11));puts("|"),!i&&m--*p[j]++;do j++,j%=n;while(p[j]);}printf("Bot #%d is the winner",j+1);}

257 bytes

VBA (Excel), 551 bytes
CellA1 as input and output in immediate window.
Sub k()
Z = [A1] - 1
ReDim p(Z)
For b = 0 To Z
p(b) = "  "
Next
Do Until i = Z
Do Until a >= 11
Randomize
a = a + CInt(IIf(a > 8, 1, IIf(a > 7, 1 + Rnd, 1 + (Rnd * 2))))
Do Until p(d) = a
p(y) = IIf(p(y) = "xx", p(y), a)
d = y
y = IIf(y = Z, 0, y + 1)
Loop
For b = 0 To Z
c = c & IIf(p(b) < 10, 0 & p(b), p(b)) & "|"
g = IIf(p(b) = "  ", b, g)
p(b) = IIf(p(b) = "xx", "xx", "  ")
Next
Debug.Print "|" & c
Application.Wait Now + #12:00:01 AM#
DoEvents
c = ""
Loop
p(d) = "xx"
i = i + 1
a = 0
Loop
Debug.Print "Bot #" & g + 1 & " is the winner."
End Sub

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
find the pattern in this number sequence of 1's and 0's
Write the shortest program or function which generates these 1000 numbers or a sequence (0- or 1-indexed) which begins with them.
[0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,
 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,
 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,
 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,
 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0,
 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,
 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0,
 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,
 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0,
 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,
 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1,
 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,
 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1,
 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0,
 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1,
 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0,
 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1,
 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0,
 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1,
 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0,
 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1,
 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0,
 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1,
 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0,
 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1,
 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0,
 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1,
 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0,
 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1,
 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0,
 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1,
 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0,
 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1,
 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0,
 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1,
 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0,
 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1,
 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0]

this is my first time posting a code puzzle.  if you have any style improvements.  let me know.

Hi John, and welcome to PPCG!  Challenges here need to have an objective win condition (usually code-golf).  We also recommend running all challenges through the sandbox before posting.

As the goal of this problem seems to be finding the sequence, I'd recommend asking for the shortest code that will generate these first 1000 elements correctly.

@Mnemonic that sounds about right.  My code is already quite short, and I'm asking if there's an even shorter code.  Feel free to edit :-) or I can just move to sandbox

I forget who did this challenge before. But it was very well received to "find the pattern". I vaguely remember someone cracking it in 50 minutes; but people continued to answer even after that.

Jelly, 11 10 bytes
Saved 1 byte thanks to @Dennis
ȷḶ×⁽q£:ȷ5Ḃ

Try it online!
How?
I first noticed that the pattern alternates between runs of length 4 and length 3, skipping the length-4 step every few runs. This led me to look for a number which could be divided into the current index, then taken mod 2 and floored—i.e. retrieving the least significant bit—to give the bit at that index in the series. After much trial and error, I found that 3.41845 does exactly that, but multiplying by its approximate reciprocal (.29253) is a byte shorter.
ȷḶ×⁽q£:ȷ5Ḃ    Main link. Arguments: none
ȷ             Yield 1e3, i.e. 1000.
 Ḷ            Lowered range; yield [0, 1, 2, ..., 999].
  ×⁽q£        Multiply each item by 29253.
      :ȷ5     Floor-divide each item by 1e5, i.e. 100000.
         Ḃ    Take each item mod 2.

ah you found it

[0...999] times each by 0.2925, mod 2 and floor (I'd go floor then mod 2 but equivalent)

Well that's quite anticlimactic, was expecting something more intricate.

@JonathanAllan I originally tried just Ḃ but apparently that's just mod 2 rather than lowest bit, so I added the Ḟ to fix it. Swapped now

Could stick with integers all the way too: ȷḶ×117:400Ḃ

@JonathanAllan That doesn't quite work, unfortunately. If it did, it could be shortened to ȷḶ×⁽¡ʋ:4ȷḂ.

ȷḶ×⁽q£:ȷ5Ḃ works, for 10 bytes.

@johnmangual Any particular reason for this number 3.41845? I first misread it as pi (3.141592...), which would have been kinda neat.

Ruby, 34 29 26 22 bytes
$.+=184while p$./629%2

Try it online!
Quick explanation: this works because of the magic number 629. I noticed that the sequence starts repeating after the 629th element, and I tried to "improve" some existing answer, using only integer math. I found that the other "magic number" (0.29253) is actually 184/629.

Dyalog APL, 99 83 82 bytes
a←{⍵/0 1}¨(↓3 2⍴4 3 3)
{a⊢←↓⍉↑a{⍺∘{⍵/⊂⍺}¨⍵}¨↓3 3⍴⍵}¨(9/5)∘⊤¨1386531 496098
1000⍴∊a

Try it online!
Definitely not the intended solution as this still has a lot of hardcoded data, but it's a start.

Jelly, 31 bytes
Given the pattern there is probably an even shorter way...
ĖŒṙḂ
“ṁ⁽⁺ḄæI’BḤ+3żḂ$ẎÇo2Ç+3Çḣȷ¬

Try it online!
How?
Exploits the repeating run length structure that is apparent to a depth of three.
ĖŒṙḂ - Link 1, make runs of bits: list of lengths    e.g. [5,3,5,3,3]
Ė    - enumerate                      [[1,5],[2,3],[3,5],[4,3],[5,3]]
 Œṙ  - run-length decode      [1,1,1,1,1,2,2,2,3,3,3,3,3,4,4,4,5,5,5]
   Ḃ - bit (modulo by 2)      [1,1,1,1,1,0,0,0,1,1,1,1,1,0,0,0,1,1,1]

“ṁ⁽⁺ḄæI’BḤ+3żḂ$ẎÇo2Ç+3Çḣȷ¬ - Main link: no arguments
“ṁ⁽⁺ḄæI’                   - literal 234931870193324
        B                  - to binary = [1,1,0,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,0,1,1,0,0]
         Ḥ                 - double    = [2,2,0,2,0,2,0,2,2,0,2,0,2,0,2,2,0,2,0,2,0,2,2,0,2,0,2,0,2,0,2,2,0,2,0,2,0,2,2,0,2,0,2,0,2,2,0,0]
          +3               - add three = [5,5,3,5,3,5,3,5,5,3,5,3,5,3,5,5,3,5,3,5,3,5,5,3,5,3,5,3,5,3,5,5,3,5,3,5,3,5,5,3,5,3,5,3,5,5,3,3]
              $            - last two links as a monad:
             Ḃ             -   bit     = [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
            ż              -   zip     = [[5,1],[5,1],[3,1],[5,1],[3,1],[5,1],[3,1],[5,1],[5,1],[3,1],[5,1],[3,1],[5,1],[3,1],[5,1],[5,1],[3,1],[5,1],[3,1],[5,1],[3,1],[5,1],[5,1],[3,1],[5,1],[3,1],[5,1],[3,1],[5,1],[3,1],[5,1],[5,1],[3,1],[5,1],[3,1],[5,1],[3,1],[5,1],[5,1],[3,1],[5,1],[3,1],[5,1],[3,1],[5,1],[5,1],[3,1],[3,1]]
               Ẏ           - tighten   = [5,1,5,1,3,1,5,1,3,1,5,1,3,1,5,1,5,1,3,1,5,1,3,1,5,1,3,1,5,1,5,1,3,1,5,1,3,1,5,1,3,1,5,1,5,1,3,1,5,1,3,1,5,1,3,1,5,1,3,1,5,1,5,1,3,1,5,1,3,1,5,1,3,1,5,1,5,1,3,1,5,1,3,1,5,1,3,1,5,1,5,1,3,1,3,1]
                Ç          - call the last Link (1) as a monad
                           -           = [1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,0]
                 o2        - OR 2      = [1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,2]
                   Ç       - Link 1... = [1,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,0]
                    +3     - add three = [4,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,4,3,3,4,3,4,3,3,4,3,4,3,3]
                      Ç    - Link 1... = [1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0]
                        ȷ  - literal 1000
                       ḣ   - head      = [1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1]
                         ¬ - NOT       = [0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0]

I've never seen Jelly before!

Welcome to PPCG :) - it's a golfing language written by one of our moderators, Dennis. Click in the header for it's git-hub page where there is a wiki.

i promise to get better at posing questions.  i see there's a sandbox and some standard formatting.

This was pretty much my approach when I started.

@EsolangingFruit I thought as I was doing it that it could be a fraction doing the repetition... 117/400 it seems!

Java 8, 75 64 62 bytes
v->{for(int i=0;i<1e3;)System.out.print((int)(i++*.29253)%2);}

Prints the entire sequence without delimiter to save bytes, because they will only be 0 and 1 anyway.
Ports of @ETHproductions' Jelly answer, because I doubt I find anything shorter..
Try it online.
Explanation:
v->{                     // Method with empty unused parameter and no return-type
  for(int i=0;i<1e3;)    //  Loop `i` in range [0,1000)
    System.out.print(    //   Print:
      (int)(i++*.29253)  //    `i` multiplied with 0.29253,
                         //    and then truncated of their decimal values by casting to int
      %2);}              //    Modulo-2 to result in either 0 or 1

Old answer returning the resulting array (75 bytes):
v->{int i=1000,r[]=new int[i];for(;i-->0;)r[i]=(int)(i*.29253)%2;return r;}

Try it online.
Explanation:
v->{                   // Method with empty unused parameter and integer-array return-type
  int i=1000,          //  Index `i`, starting at 1000
      r[]=new int[i];  //  Result-array of size 1000
  for(;i-->0;)         //  Loop `i` in range (1000,0]
    r[i]=              //   Set the item in the array at index `i` to:
      (int)(i*.29253)  //    `i` multiplied with 0.29253,
                       //    and then truncated of their decimal values by casting to int
      %2;              //    Modulo-2 to result in either 0 or 1
  return r;}           //  Return the resulting integer-array

Wolfram Language (Mathematica), 96 bytes
I searched for a cellular automaton that looks at the 4 neighbors to the left and produces the walking left pattern seen in the data when you Partition the data into length 7 and keep every third row.
This cellular automaton will run for 29 generations each of which is triplicated, matching the sequence perfectly for characters 1 to 629.  However the sequence starts repeating at the 630th character rather than continuing the observed pattern, so extra code is needed to handle the repeat of the truncated pattern. I generate the main pattern twice to get to 1258 characters.
Most@Flatten[{#,#,#}&/@CellularAutomaton[{271,2,-{{4},{3},{2},{1}}},{0,0,0,0,1,1,1},29]]~Table~2

Without that glitch we could do it in a shorter 74 bytes.  The 47 is the number of generations needed to get to 1000 characters (this actually goes to 1008=48*7*3)
{#,#,#}&/@CellularAutomaton[{271,2,-{{4},{3},{2},{1}}},{0,0,0,0,1,1,1},47]

Try it online!

Python 3, 42 bytes
x=184
while x/629%2:print(x//629%2);x+=184

Try it online!
Port of G.B.'s answer.

Stax, 13 11 bytes
í?♫~╘äqx-G▄

Run and debug it at staxlang.xyz!
Port to Stax of @ETHproductions's Jelly answer (before its modification) with some modifications by @recursive to save two bytes.

You can double the denominator, keep the fractional part, and then round to nearest integer rather than using modulus.  If I'm not mistaken, this also gives 11

JavaScript (Node.js), 41 33 bytes, port
Thank Rick Hitchcock for 4+ bytes
f=i=>i>999?'':(i*.29253&1)+f(-~i)

Try it online!
JavaScript (Node.js), 121 bytes, original
_=>'8888y888'[s='replace'](/8/g,'aaa3yyy')[s](/y/g,'aaa3aa3')[s](/a/g,34)[s](/./g,t=>(_=+!+_+[]).repeat(t)).slice(3,1003)

Try it online!

Save 4 bytes using recursion:  f=(i=0)=>i<1e3?(i*.29253&1)+f(i+1):''

Z80Golf, 27 bytes
00000000: 018d 2b7b 1f1f e601 f630 ff09 3001 1313  ..+{.....0..0...
00000010: 7bfe 9220 ee7a fe04 20e9 76              {.. .z.. .v

Try it online!
Translated from this C code:
for (n = 0; n >> 16 != 1170; n += 11149 + 65536)
    putchar('0'|n>>18&1);

Disassembly:
  ld bc, 11149
loop:
  ld a, e
  rra
  rra
  and 1
  or '0'
  rst $38           ; putchar
  add hl, bc        ; Add 11149 to n = DEHL.
  jr nc, just_one   ; Add 65536 to n, possibly with carry from low 16 bits.
  inc de
just_one:
  inc de
  ld a, e
  cp 1170 & 255
  jr nz, loop
  ld a, d
  cp 1170 >> 8
  jr nz, loop
  halt

This is essentially a fixed-point arithmetic approach: (11149 + 65536) / 218 ≈ 0.29253, the constant used by other answers.

Japt, 13 bytes
A³Ç*.29#ý f u
A³             // Given 10³,
  Ç            // map over it as a range, returning the given number
   *.29253     // times the constant,
           f u // floored and mod-2.

Japt version of ETHproduction's Jelly answer.
Bug fixed thanks to Oliver.
Try it here.

J, 17 bytes
2|<.0.29253*i.1e3

A J port of ETHproduction's Jelly answer.
Try it online!

C, 55 53 52 bytes
f(i,j){for(i=0;j=.29253*i,i++-1e3;)putchar(j%2+48);}

Port of Kevin Cruijssen's Java answer. Try it online here.
Thanks to vazt for golfing 2 bytes and to Jonathan Frech for golfing one more.
Ungolfed version:
f(i, j) { // function taking two dummy arguments (implicitly int) and implicitly returning an unused int
    for(i = 0; j = .29253*i, i++ - 1e3; ) //  loop 1000 times, multiply i with 0.29253, truncating to an integer
        putchar(j % 2 + 48);  // modulo the truncated integer by 2, yielding 0 or 1, then convert to ASCII (48 is ASCII code for '0') and print
}

i is initialized to 0 since it's global, so you can remove the i=0 from the for-loop initializer to save 3 bytes. Also if you introduce a second variable (as a parameter to f()) and assign i++*.29253 to it, you can avoid the cast and save another 2 bytes: i;f(j){for(;i<1e3;)printf("%d",(j=i++*.29253)%2);} Try it online!

@vazt Yes, i is initialized to 0 in the beginning, but if we want to call this function more than once, that's not good enough. Using j to avoid the cast is a great golf, thank you.

52 bytes.

Charcoal, 13 bytes
Ｅφ§01×·²⁹²⁵³ι

Try it online! Link is to verbose version of code. Explanation:
 φ              Predefined variable 1000
Ｅ               Map over implicit range
            ι   Current value
      ·²⁹²⁵³    Literal constant `0.29253`
     ×          Multiply
   01           Literal string `01`
  §             Cyclically index
                Implicitly print each result on its own line

Thanks to @ASCII-only for allowing indexing to accept floats which are cast to integer (and then automatically reduced modulo 2 in this case).

///, 63 bytes
/b/000111//A/b1b//B/b0b//C/0BA1//X/CACACACA0bCBCBCB/0bXXCBXCAC0

Try it online!

Deadfish~, 1301 bytes
{iiiii}ddccccicccdccccicccdccccicccdccciccccdccciccccdccciccccdcccicccdccccicccdccccicccdccciccccdccciccccdccciccccdcccicccdccccicccdccccicccdccciccccdccciccccdccciccccdcccicccdccccicccdccccicccdccciccccdccciccccdccciccccdcccicccdccccicccdccccicccdccccicccdccciccccdccciccccdcccicccdccccicccdccccicccdccccicccdccciccccdccciccccdcccicccdccccicccdccccicccdccccicccdccciccccdccciccccdcccicccdccccicccdccccicccdccccicccdccciccccdccciccccdccciccccdcccicccdccccicccdccccicccdccciccccdccciccccdccciccccdcccicccdccccicccdccccicccdccciccccdccciccccdccciccccdcccicccdccccicccdccccicccdccciccccdccciccccdccciccccdcccicccdccccicccdccccicccdccccicccdccciccccdccciccccdcccicccdccccicccdccccicccdccccicccdccciccccdccciccccdcccicccdccccicccdccccicccdccccicccdccciccccdccciccccdcccicccdccccicccdccccicccdccccicccdccciccccdccciccccdcccicccdccccicccdccccicccdccccicccdccciccccdccciccccdccciccccdcccicccdccccicccdccccicccdccciccccdccciccccdccciccccdcccicccdccccicccdccccicccdccciccccdccciccccdccciccccdcccicccdccccicccdccccicccdccciccccdccciccccdccciccccdcccicccdccccicccdccccicccdccccicccdccciccccdccciccccdcccicccdccccicccdccccicccdccccicccdccciccccdccciccccdcccicccdccccicccdccccicccdccccicccdccciccccdccciccccdcccicccdccccicccdccccicccdccccicccdccciccccdccciccccdccciccccdcccicccdccccicccdccccicccdccciccccdccciccccdc