text:
Sunset in every capital
This is a very simple challenge.
Task
Whenever your code is run, your code should output the next sunset date and time in GMT for all capital cities on Earth.  You should get the list of capitals from the below table.  The dates and times should be outputted sorted by the name of the capital. You don’t need to output the capital name.
Here is a copy of the list of capitals. Where there is more than one option your code may choose any one of them.
$$\begin{array}{l|l}
 \text{COUNTRY}                           & \text{CAPITAL CITY}                                  \\ \hline
 \text{United Arab Emirates}              & \text{Abu Dhabi}                                     \\ \hline
 \text{Nigeria}                           & \text{Abuja}                                         \\ \hline
 \text{Ghana}                             & \text{Accra}                                         \\ \hline
 \text{Ethiopia}                          & \text{Addis Ababa}                                   \\ \hline
 \text{Algeria}                           & \text{Algiers}                                       \\ \hline
 \text{Jordan}                            & \text{Amman}                                         \\ \hline
 \text{Netherlands}                       & \text{Amsterdam}                                     \\ \hline
 \text{Andorra}                           & \text{Andorra la Vella}                              \\ \hline
 \text{Turkey}                            & \text{Ankara}                                        \\ \hline
 \text{Madagascar}                        & \text{Antananarivo}                                  \\ \hline
 \text{Samoa}                             & \text{Apia}                                          \\ \hline
 \text{Turkmenistan}                      & \text{Ashgabat}                                      \\ \hline
 \text{Eritrea}                           & \text{Asmara}                                        \\ \hline
 \text{Paraguay}                          & \text{Asuncion}                                      \\ \hline
 \text{Greece}                            & \text{Athens}                                        \\ \hline
 \text{Iraq}                              & \text{Baghdad}                                       \\ \hline
 \text{Azerbaijan}                        & \text{Baku}                                          \\ \hline
 \text{Mali}                              & \text{Bamako}                                        \\ \hline
 \text{Brunei}                            & \text{Bandar Seri Begawan}                           \\ \hline
 \text{Thailand}                          & \text{Bangkok}                                       \\ \hline
 \text{Central African Republic}          & \text{Bangui}                                        \\ \hline
 \text{Gambia}                            & \text{Banjul}                                        \\ \hline
 \text{Saint Kitts and Nevis}             & \text{Basseterre}                                    \\ \hline
 \text{China}                             & \text{Beijing}                                       \\ \hline
 \text{Lebanon}                           & \text{Beirut}                                        \\ \hline
 \text{Northern Ireland}                  & \text{Belfast}                                       \\ \hline
 \text{Serbia}                            & \text{Belgrade}                                      \\ \hline
 \text{Belize}                            & \text{Belmopan}                                      \\ \hline
 \text{Germany}                           & \text{Berlin}                                        \\ \hline
 \text{Switzerland}                       & \text{Bern}                                          \\ \hline
 \text{Kyrgyzstan}                        & \text{Bishkek}                                       \\ \hline
 \text{Guinea-Bissau}                     & \text{Bissau}                                        \\ \hline
 \text{Colombia}                          & \text{Bogota}                                        \\ \hline
 \text{Brazil}                            & \text{Brasilia}                                      \\ \hline
 \text{Slovakia}                          & \text{Bratislava}                                    \\ \hline
 \text{Congo, Republic of the}            & \text{Brazzaville}                                   \\ \hline
 \text{Barbados}                          & \text{Bridgetown}                                    \\ \hline
 \text{Belgium}                           & \text{Brussels}                                      \\ \hline
 \text{Romania}                           & \text{Bucharest}                                     \\ \hline
 \text{Hungary}                           & \text{Budapest}                                      \\ \hline
 \text{Argentina}                         & \text{Buenos Aires}                                  \\ \hline
 \text{Egypt}                             & \text{Cairo}                                         \\ \hline
 \text{Australia}                         & \text{Canberra}                                      \\ \hline
 \text{Venezuela}                         & \text{Caracas}                                       \\ \hline
 \text{Wales}                             & \text{Cardiff}                                       \\ \hline
 \text{Saint Lucia}                       & \text{Castries}                                      \\ \hline
 \text{Moldova}                           & \text{Chisinau}                                      \\ \hline
 \text{Sri Lanka}                         & \text{Colombo}                                       \\ \hline
 \text{Guinea}                            & \text{Conakry}                                       \\ \hline
 \text{Denmark}                           & \text{Copenhagen}                                    \\ \hline
 \text{Senegal}                           & \text{Dakar}                                         \\ \hline
 \text{Syria}                             & \text{Damascus}                                      \\ \hline
 \text{Bangladesh}                        & \text{Dhaka}                                         \\ \hline
 \text{East Timor}                        & \text{Dili}                                          \\ \hline
 \text{Djibouti}                          & \text{Djibouti}                                      \\ \hline
 \text{Tanzania}                          & \text{Dodoma}                                        \\ \hline
 \text{Qatar}                             & \text{Doha}                                          \\ \hline
 \text{Ireland}                           & \text{Dublin}                                        \\ \hline
 \text{Tajikistan}                        & \text{Dushanbe}                                      \\ \hline
 \text{Scotland}                          & \text{Edinburgh}                                     \\ \hline
 \text{Sierra Leone}                      & \text{Freetown}                                      \\ \hline
 \text{Tuvalu}                            & \text{Funafuti}                                      \\ \hline
 \text{Botswana}                          & \text{Gaborone}                                      \\ \hline
 \text{Guyana}                            & \text{Georgetown}                                    \\ \hline
 \text{Burundi}                           & \text{Gitega}                                        \\ \hline
 \text{Guatemala}                         & \text{Guatemala City}                                \\ \hline
 \text{Vietnam}                           & \text{Hanoi}                                         \\ \hline
 \text{Zimbabwe}                          & \text{Harare}                                        \\ \hline
 \text{Cuba}                              & \text{Havana}                                        \\ \hline
 \text{Finland}                           & \text{Helsinki}                                      \\ \hline
 \text{Solomon Islands}                   & \text{Honiara}                                       \\ \hline
 \text{Pakistan}                          & \text{Islamabad}                                     \\ \hline
 \text{Indonesia}                         & \text{Jakarta}                                       \\ \hline
 \text{South Sudan}                       & \text{Juba}                                          \\ \hline
 \text{Afghanistan}                       & \text{Kabul}                                         \\ \hline
 \text{Uganda}                            & \text{Kampala}                                       \\ \hline
 \text{Nepal}                             & \text{Kathmandu}                                     \\ \hline
 \text{Sudan}                             & \text{Khartoum}                                      \\ \hline
 \text{Ukraine}                           & \text{Kiev}                                          \\ \hline
 \text{Rwanda}                            & \text{Kigali}                                        \\ \hline
 \text{Jamaica}                           & \text{Kingston}                                      \\ \hline
 \text{Saint Vincent and the Grenadines}  & \text{Kingstown}                                     \\ \hline
 \text{Congo, Democratic Republic of the} & \text{Kinshasa}                                      \\ \hline
 \text{Malaysia}                          & \text{Kuala Lumpur}                                  \\ \hline
 \text{Kuwait}                            & \text{Kuwait City}                                   \\ \hline
 \text{Bolivia}                           & \text{La Paz (administrative), Sucre (official)}     \\ \hline
 \text{Gabon}                             & \text{Libreville}                                    \\ \hline
 \text{Malawi}                            & \text{Lilongwe}                                      \\ \hline
 \text{Peru}                              & \text{Lima}                                          \\ \hline
 \text{Portugal}                          & \text{Lisbon}                                        \\ \hline
 \text{Slovenia}                          & \text{Ljubljana}                                     \\ \hline
 \text{Togo}                              & \text{Lome}                                          \\ \hline
 \text{England}                           & \text{London}                                        \\ \hline
 \text{United Kingdom}                    & \text{London}                                        \\ \hline
 \text{Angola}                            & \text{Luanda}                                        \\ \hline
 \text{Zambia}                            & \text{Lusaka}                                        \\ \hline
 \text{Luxembourg}                        & \text{Luxembourg}                                    \\ \hline
 \text{Spain}                             & \text{Madrid}                                        \\ \hline
 \text{Marshall Islands}                  & \text{Majuro}                                        \\ \hline
 \text{Equatorial Guinea}                 & \text{Malabo}                                        \\ \hline
 \text{Maldives}                          & \text{Male}                                          \\ \hline
 \text{Nicaragua}                         & \text{Managua}                                       \\ \hline
 \text{Bahrain}                           & \text{Manama}                                        \\ \hline
 \text{Philippines}                       & \text{Manila}                                        \\ \hline
 \text{Mozambique}                        & \text{Maputo}                                        \\ \hline
 \text{Lesotho}                           & \text{Maseru}                                        \\ \hline
 \text{Eswatini (Swaziland)}              & \text{Mbabana}                                       \\ \hline
 \text{Palau}                             & \text{Melekeok}                                      \\ \hline
 \text{Mexico}                            & \text{Mexico City}                                   \\ \hline
 \text{Belarus}                           & \text{Minsk}                                         \\ \hline
 \text{Somalia}                           & \text{Mogadishu}                                     \\ \hline
 \text{Monaco}                            & \text{Monaco}                                        \\ \hline
 \text{Liberia}                           & \text{Monrovia}                                      \\ \hline
 \text{Uruguay}                           & \text{Montevideo}                                    \\ \hline
 \text{Comoros}                           & \text{Moroni}                                        \\ \hline
 \text{Russia}                            & \text{Moscow}                                        \\ \hline
 \text{Oman}                              & \text{Muscat}                                        \\ \hline
 \text{Chad}                              & \text{N'Djamena}                                     \\ \hline
 \text{Kenya}                             & \text{Nairobi}                                       \\ \hline
 \text{Bahamas}                           & \text{Nassau}                                        \\ \hline
 \text{Myanmar (Burma)}                   & \text{Nay Pyi Taw}                                   \\ \hline
 \text{India}                             & \text{New Delhi}                                     \\ \hline
 \text{Niger}                             & \text{Niamey}                                        \\ \hline
 \text{Cyprus}                            & \text{Nicosia}                                       \\ \hline
 \text{Nauru}                             & \text{No official capital}                           \\ \hline
 \text{Mauritania}                        & \text{Nouakchott}                                    \\ \hline
 \text{Tonga}                             & \text{Nuku'alofa}                                    \\ \hline
 \text{Kazakhstan}                        & \text{Nur-Sultan}                                    \\ \hline
 \text{Norway}                            & \text{Oslo}                                          \\ \hline
 \text{Canada}                            & \text{Ottawa}                                        \\ \hline
 \text{Burkina Faso}                      & \text{Ouagadougou}                                   \\ \hline
 \text{Federated States of Micronesia}    & \text{Palikir}                                       \\ \hline
 \text{Panama}                            & \text{Panama City}                                   \\ \hline
 \text{Suriname}                          & \text{Paramaribo}                                    \\ \hline
 \text{France}                            & \text{Paris}                                         \\ \hline
 \text{Cambodia}                          & \text{Phnom Penh}                                    \\ \hline
 \text{Montenegro}                        & \text{Podgorica}                                     \\ \hline
 \text{Haiti}                             & \text{Port au Prince}                                \\ \hline
 \text{Mauritius}                         & \text{Port Louis}                                    \\ \hline
 \text{Papua New Guinea}                  & \text{Port Moresby}                                  \\ \hline
 \text{Trinidad and Tobago}               & \text{Port of Spain}                                 \\ \hline
 \text{Vanuatu}                           & \text{Port Vila}                                     \\ \hline
 \text{Benin}                             & \text{Porto Novo}                                    \\ \hline
 \text{Czech Republic (Czechia)}          & \text{Prague}                                        \\ \hline
 \text{Cape Verde}                        & \text{Praia}                                         \\ \hline
 \text{South Africa}                      & \text{Pretoria, Bloemfontein, Cape Town}             \\ \hline
 \text{Kosovo}                            & \text{Pristina}                                      \\ \hline
 \text{North Korea}                       & \text{Pyongyang}                                     \\ \hline
 \text{Ecuador}                           & \text{Quito}                                         \\ \hline
 \text{Morocco}                           & \text{Rabat}                                         \\ \hline
 \text{Iceland}                           & \text{Reykjavik}                                     \\ \hline
 \text{Latvia}                            & \text{Riga}                                          \\ \hline
 \text{Saudi Arabia}                      & \text{Riyadh}                                        \\ \hline
 \text{Italy}                             & \text{Rome}                                          \\ \hline
 \text{Dominica}                          & \text{Roseau}                                        \\ \hline
 \text{Grenada}                           & \text{Saint George's}                                \\ \hline
 \text{Antigua and Barbuda}               & \text{Saint John's}                                  \\ \hline
 \text{Costa Rica}                        & \text{San Jose}                                      \\ \hline
 \text{San Marino}                        & \text{San Marino}                                    \\ \hline
 \text{El Salvador}                       & \text{San Salvador}                                  \\ \hline
 \text{Yemen}                             & \text{Sana'a}                                        \\ \hline
 \text{Chile}                             & \text{Santiago}                                      \\ \hline
 \text{Dominican Republic}                & \text{Santo Domingo}                                 \\ \hline
 \text{Sao Tome and Principe}             & \text{Sao Tome}                                      \\ \hline
 \text{Bosnia and Herzegovina}            & \text{Sarajevo}                                      \\ \hline
 \text{South Korea}                       & \text{Seoul}                                         \\ \hline
 \text{Singapore}                         & \text{Singapore}                                     \\ \hline
 \text{North Macedonia (Macedonia)}       & \text{Skopje}                                        \\ \hline
 \text{Bulgaria}                          & \text{Sofia}                                         \\ \hline
 \text{Sweden}                            & \text{Stockholm}                                     \\ \hline
 \text{Fiji}                              & \text{Suva}                                          \\ \hline
 \text{Taiwan}                            & \text{Taipei}                                        \\ \hline
 \text{Estonia}                           & \text{Tallinn}                                       \\ \hline
 \text{Kiribati}                          & \text{Tarawa Atoll}                                  \\ \hline
 \text{Uzbekistan}                        & \text{Tashkent}                                      \\ \hline
 \text{Georgia}                           & \text{Tbilisi}                                       \\ \hline
 \text{Honduras}                          & \text{Tegucigalpa}                                   \\ \hline
 \text{Iran}                              & \text{Tehran}                                        \\ \hline
 \text{Israel}                            & \text{Tel Aviv (Jerusalem has limited recognition)}  \\ \hline
 \text{Bhutan}                            & \text{Thimphu}                                       \\ \hline
 \text{Albania}                           & \text{Tirana (Tirane)}                               \\ \hline
 \text{Japan}                             & \text{Tokyo}                                         \\ \hline
 \text{Libya}                             & \text{Tripoli}                                       \\ \hline
 \text{Tunisia}                           & \text{Tunis}                                         \\ \hline
 \text{Mongolia}                          & \text{Ulaanbaatar}                                   \\ \hline
 \text{Liechtenstein}                     & \text{Vaduz}                                         \\ \hline
 \text{Malta}                             & \text{Valletta}                                      \\ \hline
 \text{Vatican City}                      & \text{Vatican City}                                  \\ \hline
 \text{Seychelles}                        & \text{Victoria}                                      \\ \hline
 \text{Austria}                           & \text{Vienna}                                        \\ \hline
 \text{Laos}                              & \text{Vientiane}                                     \\ \hline
 \text{Lithuania}                         & \text{Vilnius}                                       \\ \hline
 \text{Poland}                            & \text{Warsaw}                                        \\ \hline
 \text{United States}                     & \text{Washington D.C}                                \\ \hline
 \text{New Zealand}                       & \text{Wellington}                                    \\ \hline
 \text{Namibia}                           & \text{Windhoek}                                      \\ \hline
 \text{Côte d'Ivoire (Ivory Coast)}       & \text{Yamoussoukro}                                  \\ \hline
 \text{Cameroon}                          & \text{Yaounde}                                       \\ \hline
 \text{Armenia}                           & \text{Yerevan}                                       \\ \hline
 \text{Croatia}                           & \text{Zagreb}                                        \\ \hline
\end{array}$$
Your code may use any libraries you like and may even access the Internet to get relevant data.  It may also output the dates and times in any easily human readable form you choose. You should assume the code is run in 2020. The time you give for sunset will be deemed correct if there is at least one website or data source (that existed before this question was posed) that agrees with you.

What is unclear about the question?

The question is pretty clear, but the task is under-specified (we don't know what would be a valid sunset time) and not self-contained. Also, allowing access to the Internet means that we can just store the results somewhere and download that file, making it basically a duplicate of this challenge.

@Arnauld For the second point I didn't mean that you could precompute all possible answers and then download it. That looks like it should be covered by a standard loophole (although it's not clear how to do that exactly for my challenge).

@Arnauld For the question of whether it is self-contained ... do you just mean that how to compute subset times is not given in the question?

@Anush All the information needed to write the code should be in the post (eg don't just say for all capital cities on Earth and give a link to them, actually list them in the question.) This is because you can't assume links will always work forever and ever.

@Noodle9 Good point. I will add the list in a little bit

@mypronounismonicareinstate I am sorry you find it boring and even more sorry you are annoyed that there are two related questions!   Answers to the other question will in no way help you solve this question, if that helps at all.

Could we output in mixed times for the region of the specific city, as long as we mention it? I.e. ...; Addis Ababa 18:40 (GMT+3); Algiers 19:57 (CET); Amman 19:34 (EEST); Amsterdam 21:46 (CEST); ...?

@KevinCruijssen That sounds ok. Is it much harder to output in GMT?

@Anush Unless you can provide me with a website that has the GMT time of each city based on a given url (so not JavaScript / PHP script based like almost all I could find are), then it's indeed harder to output all in GMT, since I have to manually convert each one of them from those varied times to GMT.. The website I used gives the time of each city in their own time region unfortunately.. :/

@KevinCruijssen OK. I am happy with your suggestion.

I'm not sure how can this be reopened, as there still is not a list of the locations of the capitals, as far as I see.

@mypronounismonicareinstate There is a huge list of cities. Or do you mean what longitude/latitude each city has, or what time zone they are in?

Could you please put the list in a pastebin or scrollable code block or something? It being so long is an issue reading on mobile.

05AB1E, 106 bytes
’»‚†Ò‚Ÿ.ŒŒ/‚ïŒÇíÇ.htm’.w’¡Õ="17">’¡ε'<¡н„,(S¡н}¦āÈÏ{ε’Š¹.ŒŒ/€±?q=¿Ô+ÿ+ƒÜ’.w©’ƒ£-c·¼:2">’¡θ5£®žg…ÿ (¡θ')¡н‚

Couple of assumptions, which are allowed and/or required for the challenges:

The program is run in 2020.
The url https://geographyfieldwork.com/WorldCapitalCities.htm is accessible and contains the html shown in the second TIO below
Google is accessible and contains the html shown in the fourth TIO below
[Temporarily] Assumes Elixir (in which 05AB1E is built) accessing a website makes adjustments similar to a browser (i.e. implicitly adds https:// and converts spaces to %20). I'll try to verify this locally in a moment. If this isn't true, I'll delete this answer and fix it.

Outputs all times in their respective time zones instead of all in GMT as the challenge description states, which OP allowed in the comments.
This will be output as a list of pairs, where each pair is the time with a timezone (i.e. ["21:46","CEST"]).
No direct TIO, since the .w builtin (to access a website) is disabled on TIO. But:
’»‚†Ò‚Ÿ.ŒŒ/‚ïŒÇíÇ.htm’

Try this part online to see the generation of the URL.
’¡Õ="17">’¡ε'<¡н„,(S¡н}¦āÈÏ{

Try this part online to see it creates the sorted list of cities based on the website's HTML content.
’Š¹.ŒŒ/€±?q=¿Ô+ÿ+ƒÜ’

Try this part online to see the generation of the Google-search URL.
©’ƒ£-c·¼:2">’¡θ5£®žg…ÿ (¡θ')¡н‚

Try the TIO in this pastebin (the link of the TIO itself is too large.. -_-) to see it creates the correct result for a given city based on the Google's search result HTML content.
Explanation:
’»‚†Ò‚Ÿ.ŒŒ/‚ïŒÇíÇ.htm’ # Push dictionary string "geographyfieldwork.com/worldcapitalcities.htm"
 .w                    # Access this website and read its HTML content
   ’¡Õ="17">’          # Push dictionary string 'height="17">'
             ¡         # Split the html on that
              ε        # Map each string-part to:
               '<¡    '#  Split it on "<"
                  н    #  And only leave the first part
               „,(S¡   #  Split that part by "," and "("
                    н  #  And again only leave the first part
              }¦       # After the map: remove the first empty string
                       # (we now have a list of all unordered countries + cities)
                ā      # Push a list in the range [1,length] (without popping)
                 È     # Check for each value whether it's odd
                  Ï    # Only leave the strings at those truthy values
                   {   # And sort those alphabetically

We now have a sorted list of all cities.
ε                      # Map each city to:
 ’Š¹.ŒŒ/€±?q=¿Ô+ÿ+ƒÜ’  #  Push dictionary string "google.com/search?q=sunset+ÿ+today",
                       #  where the `ÿ` is automatically filled with the city
 .w                    #  Access this website and read its HTML content
   ©                   #  Store it in variable `®` (without popping)
    ’ƒ£-c·¼:2">’      "#  Push dictionary string 'line-clamp:2">'
                ¡      #  Split the content on that
                 θ     #  Only leave the last (second) part
                  5£   #  Only leave the first 5 characters (the time)
   ®                   #  Push the HTML content again
    žg                 #  Push the current year (2020)
      …ÿ (             #  Push string "ÿ (", where the `ÿ` is filled with 2020: "2020 ("
          ¡            #  Split the content on that
           θ           #  Only leave the last (second) part
            ')¡       '#  Split it on ")"
               н       #  And leave the first item (the timezone)
   ‚                   #  Pair the time and timezone strings together
                       # (after which the resulting mapped pair of strings is output implicitly)

See this 05AB1E tip of mine (section How to use the dictionary?) to understand why ’»‚†Ò‚Ÿ.ŒŒ/‚ïŒÇíÇ.htm’ is "geographyfieldwork.com/worldcapitalcities.htm"; ’¡Õ="17">’ is 'height="17">'; ’Š¹.ŒŒ/€±?q=¿Ô+ÿ+ƒÜ’ is "google.com/search?q=sunset+ÿ+today"; and ’ƒ£-c·¼:2">’ is 'line-clamp:2">'.

Very nice! (Typo: GTM -> GMT)

@Anush Fixed the typo ;)

Does Google return the time of sunset for somtething like sunset La Paz (administrative), Sucre (official) today (or does this somehow handle such cases?)?

@mypronounismonicareinstate Thanks for noticing! Fixed that one, as well as Tirana (Tirane), Tel Aviv (Jerusalem has limited recognition) and Pretoria, Bloemfontein, Cape Town at the cost of 6 bytes.


text:
Let's study Neil numbers
Congratulations to Neil for hitting 100k rep! As a tribute, we are going to study 'Neil numbers'.
Neil's user ID is 17602 and there's something special about the binary representation of this number:
$$17602_{10}=1\color{blue}{000}1\color{blue}{00}11\color{blue}{0000}1\color{blue}{0}_2$$
$$\begin{array}{c|c}
1&\color{blue}{000}&1&\color{blue}{00}&11&\color{blue}{0000}&1&\color{blue}{0}\\
\hline
&3&&2&&4&&1
\end{array}$$
There's exactly one group of consecutive zeros of length 1, one group of length 2, one group of length 3 and one group of length 4.
This is an order-4 Neil number.
More generally:

An order-\$n\$ Neil number is a positive integer whose binary
  representation contains exactly \$n\$ groups of consecutive zeros and
  for which there's exactly one group of consecutive zeros of length
  \$k\$ for each \$0<k\le n\$, with \$n>0\$.

Clarifications:

Leading zeros are obviously ignored.
Groups of consecutive zeros are indivisible (e.g. 000 is a group of length 3 and cannot be seen as a group of length 1 followed by a group of length 2, or the other way around).

Examples
Order-1 Neil numbers are A030130 (except 0, which is not a Neil number as per our definition).
The first few order-2 Neil numbers are:
18, 20, 37, 38, 41, 44, 50, 52, 75, 77, 78, 83, 89, 92, 101, 102, 105, 108, 114, ...

Your task
Given a positive integer as input, return \$n\ge 1\$ if this is an order-\$n\$ Neil number or another consistent and non-ambiguous value (0, -1, false, "foo", etc.) if this is not a Neil number at all.
This is code-golf.
Test cases
Using 0 for non-Neil numbers:
Input   Output
1       0
2       1
8       0
72      0
84      0
163     0
420     0
495     1
600     3
999     0
1001    2
4095    0
8466    4
16382   1
17602   4
532770  5

Or as lists:
Input : 1, 2, 8, 72, 84, 163, 420, 495, 600, 999, 1001, 4095, 8466, 16382, 17602, 532770
Output: 0, 1, 0, 0, 0, 0, 0, 1, 3, 0, 2, 0, 4, 1, 4, 5

Brownie points if your user ID is a Neil number. :-)

technically there's also a gap between 1s with zero length too!

@JoKing I actually hesitated to include 0-length gaps in the definition. The main reason why I didn't is that there would be just one order-0 Neil number (3) and 0 could not be used to represent a falsy result anymore. The other reason is that there would be much less Neil numbers.

This is a great question! It reminds me that from time to time I will see a crossword where one or more of the words intersects with other words in the form --+---+-+----.

Speaking of congratulations, I think you might have surpassed @xnor and become the 3rd place all-time high earlier this month?

84 is a good test case as it has a double run of single 0s.

@Noodle9 Added :)

I knew it! Tributes to other users always include the word "user id". This one isn't an exception.

Minor typo: "is this is not a Neil number at all" should be "if this is not a Neil number at all".

@numbermaniac Good catch. Fixed!

Charcoal, 21 bytes
≔Φ⪪⍘Ｎ²1ιθＩ×Ｌθ⬤θ№θ×0⊕κ

Try it online! Link is to verbose version of code. Outputs 0 for irrelevant numbers. Happens to output 1 for 0 as per the OEIS sequence. Explanation:
≔Φ⪪⍘Ｎ²1ιθ

Convert the input to binary, split on 1s, and remove empty elements.
Ｉ×Ｌθ⬤θ№θ×0⊕κ

Check that the array contains all lengths of 0s and output its length if it does or 0 if it does not.

I'm not sure, but I think you may qualify for the brownie points

Python 2, 88 86 bytes
-2 bytes thanks to @David!
s=sorted([0]+map(len,bin(input()).split("1")[1:]))
n=s[-1]
print(s[~n:]==range(n+1))*n

Try it online!
Finds the length of all zero groups, sorts them, and check if the sorted list is 1, 2, 3, ...

Same idea in Python 3.8:
Python 3.8, 85 82 bytes
lambda n:(m:=max(s:=sorted(map(len,f"{n:b}".split("1")))))*(s[~m:]==[*range(m+1)])

Try it online!

This is slightly shorter if you use map instead of for Try it online!

05AB1E, 16 15 13 bytes
b1¡€gZ©L¢PΘ®*

Outputs 0 as falsey result.
Try it online or verify all test cases.
Explanation:
b              # Convert the (implicit) input to a binary-string
               #  i.e. 163 → "10100011"
               #  i.e. 420 → "110100100"
               #  i.e. 600 → "1001011000"
 1¡            # Split it on 1s
               #  → ["","0","000","",""]
               #  → ["","","0","00","00"]
               #  → ["","00","0","","000"]
   €g          # Take the length of each chunk
               #  → [0,1,3,0,0]
               #  → [0,0,1,2,2]
               #  → [0,2,1,0,3]
     Z         # Get the maximum (without popping)
               #  → 3
               #  → 2
               #  → 3
      ©        # Store it in variable `®` (without popping)
       L       # Pop an push a list in the range [1,maximum]
               #  → [1,2,3]
               #  → [1,2]
               #  → [1,2,3]
        ¢      # Get the count of each in the list of chunk-lengths
               #  → [0,1,3,0,0] and [1,2,3] → [1,0,1]
               #  → [0,0,1,2,2] and [1,2] → [1,2]
               #  → [0,2,1,0,3] and [1,2,3] → [1,1,1]
         P     # Get the product of that
          Θ    # And check that it's exactly 1
               #  → 0 ==1 → 0 (falsey)
               #  → 2 ==1 → 0 (falsey)
               #  → 1 ==1 → 1 (truthy)
           ®*  # Multiply it by the maximum we stored in variable `®`
               #  → 0*3 → 0
               #  → 0*2 → 0
               #  → 1*3 → 3
               # (after which the result is output implicitly)

APL (Dyalog Extended), 17 bytes
Anonymous tacit prefix function. Any visual similarity with OP is entirely unintentional.
(≢×⍳⍤≢≡∘∧≢¨)~⍤⊤⊆⊤

Try it online!
The structure and order of execution is as follows:
  ┌────────┴───────┐
┌─┼──────┐      ┌──┼──┐
≢ ×  ┌───┼───┐ ~⍤⊤ ⊆  ⊤
    ⍳⍤≢ ≡∘∧ ≢¨
7 8  5   6   4  2  3  1

⊤ base-Two representation
⊆ extract sub-lists according to the runs of 1s in…
~⍤⊤ negated (0→1, 1→0) base-Two representation
(…) apply the following function to that:
 ≢¨ the length of each run
 ≡∘∧ when sorted, does it (0/1) match…
 ⍳⍤≢ the indices of the length?
× multiply that by…
≢ the length

15

Retina 0.8.2, 54 bytes
.+
$*
+`(1+)\1
$1O
(O?1)+
1
O`O+
(^1O|\1O)+1?$|.+
$1
O

Try it online! Link includes test cases. Explanation:
.+
$*

Convert to unary.
+`(1+)\1
$1O

Begin base 2 conversion, but using O instead of 0 as \10 would be an octal escape.
(O?1)+
1

As part of base 2 conversion we need to remove one O before each 1. This additionally also collapses all runs of 1s into a single 1, which simplifies matching the consecutive runs of Os later.
O`O+

Sort the runs of Os in ascending order of length.
(^1O|\1O)+1?$|.+
$1

Try to match 1O, then in each repeat match one more O than last time, finally matching an optional 1 at the end. If this succeeds, output the last match (including the leading 1), otherwise output nothing.
O

Count the Os in the last match.

J, 30 24 bytes
0(#*/:~-:#\)@-.~#;._1@#:

Try it online!
-6 bytes thanks to Bubbler
Fittingly, J has been bested here by Neil's Charcoal answer.

Using 0 for non-neil numbers seems better at 24 bytes, using the idea from APL answer.

An interesting alternative 24 using determinant, which happens to ignore extra zero rows.

@Bubbler Thanks.  It definitely felt like I was missing a simplification but I missed that one.  The determinant is slick, though I don't completely understand how it works.  Might be worth posting separately with explanation.

R, 94 85 75 74 bytes
n=scan();z=rle(n%/%2^(0:log2(n))%%2);N=max(0,s<-z$l[!z$v]);N*all(1:N%in%s)

Try it online!
Edit: -10 bytes thanks to Giuseppe
Edit 2: -1 more byte thanks again to Giuseppe
Finds differences (diff) between remainders of each power-of-two (n%%2^(0:(l=log2(n))); when sequential remainders are the same, this corresponds to a run of 'zero bits'.  rle calculates run lengths, and s extracts runs of zeros.  If s contains all the integers up to it's length N, then it's a 'Neil number'.

75 bytes. Nice approach! We had the same sort of thoughts, but your Neil-number condition was much cleverer than mine -- I had 84 bytes

I'm also wondering if you could do N=max(s<-z$l[!z$v]), but I always seem to miss an edge case where tricks like that don't work.

Thanks (yet) again, Giuseppe!  I'm quite ashamed about the number of 'fossil' parentheses and unused variable assignments that seem to be buried in my original post (some from previous-but-discarded attempts), waiting to be dug up...

And - yes - I also struggled trying to use max, but without success for the n=1 case...

Could do this for 74 using max.

Also, don't worry, when you golf for long enough, it becomes a habit. And then it starts to creep into your "real" code and it all becomes an unintelligible mess, at least to anybody else ;-)

Super!  Thankyou!  I've been re-arranging all the <-s and =s trying to figure-out just why max allows the extra byte, and all the other combinations seem to creep-up and deny it at the last moment...

C (gcc), 116 \$\cdots\$ 78 77 bytes
Saved 8 11 bytes thanks to ceilingcat!!!
Had to fix a bug, for numbers like \$84\$ (\$1010100_{2}\$) which have multiple runs of single \$0\$s, which added 3 bytes.
Saved 14 bytes thanks to a suggestion from the man himself Arnauld!!!
Added 6 bytes to fix bugs for numbers with multiple runs of zeros of the same length.
c;b;f(n){for(c=3;n;n/=b,c=c&b&~3?n=0:c|b)b=1<<ffs(n);n=ffs(++c)-3;n*=c<8<<n;}

Try it online!
Returns \$n\$ for an input of an order-\$n\$ Neil number or \$0\$ otherwise.
How?
Performs a bit-wise logical-or summation \$c=3+\sum{2^{r+1}}\$, where \$r\$ is the length of a zero bit run for all runs in the input number (including zero length runs). Checks to see if we've seen the same non-zero length run before and returns \$0\$ if we have.  After all the input's zero-bit runs have been added to \$c\$ in this manner, \$c\$ is tested to see if we've seen \$n\$ zero-bit runs of lengths \$(1,2,\dots,n)\$ by testing if \$c\stackrel{?}{=}2^{n+2}-1\$ and returns \$n\$ if this is true, \$0\$ otherwise.

I got 79 bytes by rewriting from scratch with a single for loop. My solution uses ffs().

@Arnauld I got 77 bytes! :D

Very nicely done!

Zsh, 76 bytes
for g (${(s[1])$(([#2]$1))#??})((a[$#g]++))
<<<${${${${a/#%/0}:#1}:+0}:-$#a}

Try it online!
Explanation:
${(s[1])$(([#2]$1))#??}

Convert to binary, remove the 2# prefix, and split the string on 1, giving us our groups of zeroes.
for g ( ... )((a[$#g]++))

For each group of zeroes, increment the array at the index given by the length of that string.
${a/#%/0}

Substitute the array with empty elements filled with zeroes. (If we only increment the array at a[3], then this will set a[1]=a[2]=0)
${${${${ ... }:#1}:+0}:-$#a}

Remove all 1s. If there is anything left (some a[n] != 1), then substitute 0. Otherwise (all a[n] = 1) substitute the length of the array.

Jelly, 12 bytes
BŒɠḊm2ṢJƑȧ$Ṫ

A monadic Link accepting a positive integer which yields the order (or 0 if not a Neil number).
Try it online! Or see the test-suite.
How?
BŒɠḊm2ṢJƑȧ$Ṫ - Link: positive integer, V       e.g. 600
B            - convert V to binary                  [1,0,0,1,0,1,1,0,0,0]
 Œɠ          - run lengths of equal elements        [1,2,1,1,2,3]
   Ḋ         - dequeue                              [2,1,1,2,3]
    m2       - modulo-two slice                     [2,1,3]
      Ṣ      - sort                                 [1,2,3]
          $  - last to links as a monad:
        Ƒ    -   is invariant under?:               1
       J     -     range of length                  (since range(len([1,2,3]))==[1,2,3])
         ȧ   -   logical AND                        [1,2,3]
           Ṫ - tail (if empty yields 0)             3

Alternative start: Bṣ1Ẉḟ0ṢJƑȧ$Ṫ

Brachylog, 13 bytes
ḃḅ{h0&l}ˢo~⟦₁

Try it online!
 ḅ               Take the runs of
ḃ                the input's binary digits,
  {h0  }ˢ        keep only those that start with 0,
  {  &l}ˢ        and map them to their lengths.
         o       The sorted run lengths
          ~⟦₁    are the range from 1 to the output.

Fun fact, my original attempt was ḃḅo{h0&l}ˢ~⟦₁, but it mysteriously created a choice point giving me some false positives, so I moved the o later to save on a !.

Haskell, 113 bytes
g.f
f 0=[0]
f x|h:t<-f$div x 2=[0|odd x]++(h+1-mod x 2):t
g x|n<-maximum x,r<-[1..n]=sum[n|r==[k|k<-r,y<-x,k==y]]

Try it online!

COW, 234 bytes
oomMMMMOOOOOmoOMMMMOOMOomoOMoOmOoMMMMOOMMMMOomoOMOomOomOoMoOmoOMMMOOOmooMMMmoomoOmoOMoOmOoMOOmoOMOoMOOMMMmoOmoOMMMMOomoomoOMoOmOoMoOMOOmOomOomoomoOmoOOOOmOoOOOmoomOomOoMMMmoomoOmoOmoOmoOmoOMOOMMMMoOMMMmoOMOoMOOOOOMMMmOomoomoOmooMMMOOM

Try it online!
Forms a "string" \$S\$ where:
\$k\in \{1,\dots,n\}\$

Even indexes (or control cells) \$2k-2\$ serve:

to navigate \$S\$
to know where \$S\$ ends
to count up to \$n\$

Odd indexes (or k-cells) \$2k-1\$ contain how many consecutive \$k\$ zeros there are

The idea is: when a group of consecutive \$k\$ zeros is found, its k-cells in \$S\$ is incremented.
Hence the input is a order-\$n\$ Neil number if and only if all k-cells are \$1\$.
If so, their quantity \$n\$ will be returned.
0 is returned otherwise.
Explanation
moo ]    mOo <    MOo -    OOO *    OOM i
MOO [    moO >    MoO +    MMM =    oom o

[0]: a/2     [1]: a     [2]: a%2     [3]: counter of current group of 0 (k)     [4]: // unused stuff    [5]: S(0)

i=                               ;   Read a in [0], copy
[                                ;   While [0]
    *>=                          ;      Clear [0], paste in [1]
    [                            ;      While [1]
        ->+<=[=->-<<+>=*]=       ;          {REPEATED SUBTRACTION}
    ]                            ;      [0] is a/2, [1] is 0, [2] is a%2
    >>+<                         ;      Increment [3]                                                   // here [3] is k+1
    [                            ;      If [2] {UPDATE THE STRING}                                      // if a%2==1 the current group of 0 it's been truncated
        >-                       ;          Decrement [3]                                                   // [3]-=1 (k)
        [=>>=-]                  ;          While [x] copy it in [x+2] and decrement it                     // moves to control cell 2k-2 and leaves a trail of control cells behind
        >+<                      ;          Increment [x+3]                                                 // k-cell 2k-1 +=1
        +[<<]                    ;          "Open" [x+2], while [x] x-=2                                    // use the trail to return back to [1]
        >>*<*                    ;          Clear [2] and [3]
    ]                            ;
    <<=                          ;   Point to [0], copy
]                                ;
>>>>>                            ;      Point to [5]                                                    // the first control cell in S
[                                ;      While [x] is non-zero                                           // while S has not ended
    =+=                          ;          Paste, increment [x], copy                                  // counting (n)
    >-                           ;          Move to [x+1] and decrement                                     // k-cell-=1
    [                            ;          {NOT A NEIL NUMBER}                                             // iff k-cell is non-zero
        *=<                      ;              Divert the flow (performs this loop 2 times, copy 0)
    ]                            ;              will now break the parent while|
    >                            ;      Point to [x+2]                         |                        // next control cell
]                                ;                                             |
=o                               ;   Paste (n or 0) and print                  v

Cell [4] contains the number of groups of consecutive ones that are larger than \$1\$, +1 if LSB is 1.
Nothing relevant for the task, but I couldn't get rid of it staying in this byte count.
Here's a var dump from [4].

Java (JDK), 126 117 116 bytes

Saved 1 byte thanks to ceilingcat
Saved 6 bytes - 9, really - thanks to Arnauld

q->{int C[]=new int[9],s=0,n=0;for(;q>0;q/=2)C[s]-=q%2<1?(n=++s>n?s:n)-n:~(s=0);while(q++<n)n=C[q]!=1?0:n;return n;}

Try it online!
Returns 0 for non-Neil numbers.
I feel like this should be smaller, even though it is in Java.
Ungolfed:
q -> {
  int C[] = new int[9],  //C[i] is how many times a streak of length i appeared
      s = 0,             //Length of current streak of zeroes
      n = 0;             //Max streak
  for(; q > 0; q /= 2)   //Go through all of q's digits until q=0
    C[s] -= q % 2 < 1                //If there's a 0 here
            ? (n = ++s > n ? s : n)//Increment s and set n to the max of s and n
               - n      //Subtract n from that because C[s] should stay the same
            : ~(s = 0);  //Otherwise, set s to 0 and add 1 to C[s] (the previous value of s)
  while(q++ < n)           //For every q 0 < q <= n
    n = C[q] != 1 ? 0 : n; //if there was not exactly 1 group of length q, set n to 0
  return n;
}

Some bytes saved.

MATL, 14 bytes
BY'w~)SttfX=*z

For non Neil numbers the output is 0.
Try it online! Or verify all test cases.
Explanation
Consider input 532770 as an example.
B     % Impicit input. Convert to binary
      % STACK: [1 0 0 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0 1 0]
Y'    % Run-length encoding. Gives values and run lengths
      % STACK: [1 0 1 0 1 0 1 0 1 0], [1 5 1 4 1 2 1 3 1 1]
w~    % Swap, negate element-wise
      % STACK: [1 5 1 4 1 2 1 3 1 1], [0 1 0 1 0 1 0 1 0 1]
)     % Indexing (use second input as a mask into the first)
      % STACK: [5 4 2 3 1]
S     % Sort
      % STACK: [1 2 3 4 5]
tt    % Duplicate twice
      % STACK: [1 2 3 4 5], [1 2 3 4 5], [1 2 3 4 5]
f     % Find: (1-based) indices of nonzeros
      % STACK: [1 2 3 4 5], [1 2 3 4 5], [1 2 3 4 5]
X=    % Equal (as arrays)?
      % STACK: [1 2 3 4 5], 1
*     % Multiply, element-wise
      % STACK: [1 2 3 4 5]
z     % Number of nonzeros. Implicit display
      % 5

perl -MList::Util=max -MList::Util=uniq -pl, 72 71 bytes
@==map{y===c}sprintf("%b",$_)=~/0+/g;$_=(@===max@=)&(@===uniq@=)?0+@=:0

Try it online!
Reads a number from the input, convert it to a string with the number in binary format, extracts the sequences of 0, takes their length, then prints the number of sequences of 0s if 1) there are no duplicates, and 2) the max length equals the number of sequences. Else, 0 is printed.
Edit: Saved a byte by replace && with & which works, since the result of == is 1 or the empty string, which perl treats as 0 if the operator expects a number.

That looks much like my first attempt, but I found a shorter way.

Perl 5 -pl, 61 bytes
$a=1;$_=sprintf'%b',$_;$a++while s/10{$a}(?!0)//;$_=!/0/*--$a

Try it online!
Converts number to binary, then removes the 0 sequences in order, starting at 1.  When it no longer finds a match, that's the Neil number.

That approach is wrong. For instance, 81 = 0b1010001. Your code stops because it cannot find a sequence of length 2, and then concludes it's a Neil number of order 1. That's incorrect, because there is sequence of length 3, making this not a Neil number.

Fixed it.  Forget to check if there were any 0s in the binary representation when it's done.

56 bytes. Prints N in unary.

Python 2, 90 bytes
a=[len(z)-1for z in sorted(bin(input())[2:].split('1'))if z]
n=len(a)
print(range(n)==a)*n

Try it online!
I found almost the same solution as Surculose Sputum.
They had the further insight to get rid of the [] so go upvote them :)

Factor, 146 bytes
: f ( n -- n ) >bin [ = ] monotonic-split [ first 48 = ] [ length ] filter-map
natural-sort dup dup length [1,b] >array = [ last ] [ drop 0 ] if ;

Try it online!
Not golfy at all with all the mandatory spaces and those long words...

Wolfram Language (Mathematica), 93 bytes
If[Sort[s=Length/@Take[Split@IntegerDigits[#,2],{2,-1,2}]]==Range@If[s=={},t=0,t=Max@s],t,0]&

Try it online!

Haskell, 118 bytes
n#0=[n]
n#i|mod i 2<1=(n+1)#div i 2|u<-0#div i 2=n:u
n%[]=n-1
n%x|1/=sum[1|a<-x,a==n]=0|m<-n+1=m%filter(>n)x
(1%).(0#)

Try it online!

Ruby, 67 58 57 55 bytes
->n{i=0;('%b'%n).scan(/0+/).sort.all?{_1==?0*i+=1}?i:0}

Try it online! (+2 bytes because TIO doesn't support ruby 2.7's _1)
-2 bytes thanks to Dingus

Save 2 bytes by testing the value of _1 instead of its size.

Husk, 14 10 bytes
£ḣ∞0OfΛ¬gḋ

Try it online!
-4 bytes from Zgarb.

o…1L can be ŀ

In fact, you can use £ to get 10 bytes

Japt, 15 bytes
Returns 0 for falsey.
¤ôÍmÊÍf
Ê*UeUÊõ

Try it or run all test cases
¤ôÍmÊÍf\nÊ*UeUÊõ     :Implicit input of integer                         > 17602
¤                    :To binary string                                  > "100010011000010"
 ô                   :Split at elements that return truthy
  Í                  :  When converted to decimal (0=falsey, 1=truthy)  > ["","000","00","","0000","0"]
   m                 :Map
    Ê                :  Length                                          > [0,3,2,0,4,1]
     Í               :Sort                                              > [0,0,1,2,3,4]
      f              :Filter, to remove 0s                              > [1,2,3,4]
       \n            :Assign to variable U
         Ê           :Length                                            > 4
          *          :Multiplied by
           Ue        :  Test U for equality with
             UÊ      :    Length of U                                   > 4
               õ     :    Range [1,length]                              > [1,2,3,4]
                     :Implicit output of result                         > 4

Io, 124 bytes
Just a port of the 05AB1E answer.
method(x,i :=x asBinary lstrip("0")split("1")map(size);if(Range 1 to(i max)map(x,i select(o,o==x)size)reduce(*)==1,i max,0))

Try it online!

source: Stack Exchange

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

sort: votes


text:
Cheat activated
Background
The game Grand Theft Auto: San Andreas went down in history also thanks to its wide selection of cheats. They're almost 90 and anyone who has ever touched this game, no doubt has tried them all!
One cheat is activated (on PC) typing in-game a secret keyword, and then boom, a jet pops out of thin air or perhaps all pedestrians look like Elvis Presley or some other rowdy effect...
They always come with this confirmation message:

Rockstar chose to store them hashed, so due to collisions, in addition to the intended ones there are many other strings that trigger each cheat.
Therefore I propose to solve this downside!
Task
Write a full program that prints CHEAT ACTIVATED if and only if the last part of a string is a cheat code.
Cheat codes
THUGSARMOURY
PROFESSIONALSKIT
NUTTERSTOYS
INEEDSOMEHELP
TURNUPTHEHEAT
TURNDOWNTHEHEAT
PLEASANTLYWARM
TOODAMNHOT
DULLDULLDAY
STAYINANDWATCHTV
CANTSEEWHEREIMGOING
TIMEJUSTFLIESBY
SPEEDITUP
SLOWITDOWN
ROUGHNEIGHBOURHOOD
STOPPICKINGONME
SURROUNDEDBYNUTTERS
TIMETOKICKASS
OLDSPEEDDEMON
DOUGHNUTHANDICAP
NOTFORPUBLICROADS
JUSTTRYANDSTOPME
WHERESTHEFUNERAL
CELEBRITYSTATUS
TRUEGRIME
ALLCARSGOBOOM
WHEELSONLYPLEASE
STICKLIKEGLUE
GOODBYECRUELWORLD
DONTTRYANDSTOPME
ALLDRIVERSARECRIMINALS
PINKISTHENEWCOOL
SOLONGASITSBLACK
FLYINGFISH
WHOATEALLTHEPIES
BUFFMEUP
LEANANDMEAN
BLUESUEDESHOES
ATTACKOFTHEVILLAGEPEOPLE
LIFESABEACH
ONLYHOMIESALLOWED
BETTERSTAYINDOORS
NINJATOWN
LOVECONQUERSALL
EVERYONEISPOOR
EVERYONEISRICH
CHITTYCHITTYBANGBANG
CJPHONEHOME
JUMPJET
IWANTTOHOVER
TOUCHMYCARYOUDIE
SPEEDFREAK
BUBBLECARS
NIGHTPROWLER
DONTBRINGONTHENIGHT
SCOTTISHSUMMER
SANDINMYEARS
KANGAROO
NOONECANHURTME
MANFROMATLANTIS
LETSGOBASEJUMPING
ROCKETMAN
IDOASIPLEASE
BRINGITON
STINGLIKEABEE
IAMNEVERHUNGRY
STATEOFEMERGENCY
CRAZYTOWN
TAKEACHILLPILL
FULLCLIP
IWANNADRIVEBY
GHOSTTOWN
HICKSVILLE
WANNABEINMYGANG
NOONECANSTOPUS
ROCKETMAYHEM
WORSHIPME
HELLOLADIES
ICANGOALLNIGHT
PROFESSIONALKILLER
NATURALTALENT
OHDUDE
FOURWHEELFUN
HITTHEROADJACK
ITSALLBULL
FLYINGTOSTUNT
MONSTERMASH

Input

A string \$s\$ over the alphabet:
[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z]

Output

Print CHEAT ACTIVATED if there exists a cheat code \$c\$ such that \$c\$ is a suffix of \$s\$
Nothing otherwise

This is code-golf, so the shortest code wins.

Was there a reason you chose to override the default decision problem output choices? It doesn't appear to add much beyond being cute. The rules also seem to require that the input be all capital, and not allowed to be lower case - this is abnormal and you should probably draw more attention to it if you decide to keep it.

@FryAmTheEggman Yes you've nailed it, I just like the idea of recreating the original reply of the game. I'm aware it adds almost nothing, nevertheless it's suitable to some clever "recycling" of the part of the program that checks the input. For the second part I originally thought to allow all characters and make it case insensitive, then I saw that limit the input could only make the things easier and foster optimization. (I left out one cheat 18HOLES because was the only one with digits) Beside being abnormal, show me what problem could it lead and I'm willing to change it

@FryAmTheEggman Don't get me wrong, I've not justified a whim saying that it can be interesting to see how to handle that output. I really consider it can represent something different. Of course outside Code Golf this would only be a juxtaposition of a decision problem and the production of a specific string. And I totally agree that a good challenge is a dry one, one where everything is essential. But this doesn't want to be a default decision problem. And that output it's fundamental in it.

That is fine, I'd just like to say that I think it is unlikely your choices will improve the solutions that you receive. Generally, giving the golfer more freedom to choose I/O increases the quality of the responses you get, in addition to improving the chances you get of getting responses at all.

@FryAmTheEggman Ok thanks, I'll try to leave as it is, if it didn't get many responses I'll know why ahahah - Never mind, it's an experiment :)

Python 3,  976  965 bytes
Saved 11 bytes thanks to @user202729
Nothing fancy here. This is a hand-crafted regular expression which was randomly shuffled to please zlib and save a few more bytes.
import zlib,base64,re
if re.search(zlib.decompress(base64.a85decode('''GaqK,9,=TU&D^"aoJ0#fKbc'=7=3*ZC@Sjrb9-nO,G4ij>guO6,*oNLi[tq[ZsOTo,XZG;oZsh/gQt)R:U?gtgs2QpS5&Cl,CM,c4B%`<W5ZEuN=Sb$f!,mP`%@TQ:&Dg(:q8*+N)Y?Q#F9kM'KZ&%\I2W`#7oOUp1-0Ge3]q_o8g@lWflG`*QMr*9[[`i?a`=U:auDF%8=66MDaNUUiPI8J#lO0\l@*E:%PS)VCHdD>/N`=l1`t*hVA<^ON+dhUtN/]3U\\tupZtkD$:DPFh-HW3PZ$AAiEFm(g;<YJ6I4"uMdQX16JBN/W.`>QFrON6O,^B%Jl3Mn<d^IObA<=$[b;g`-:O$Ga?$ch!SrhQNm;`Led6I;8/VCeIra;1&X%b)&*]\XB4+g3`FkTT#fc%HR8*)g95de$99CT;oVaps<Yn\im/BJu&A6-O8L3#Ha0p6]PKP2a7,,T6[K>'rQiC1R,U1_Ko/:-EAfrcS7ik6HfK>2:cMot]rkBY#!9d"ujd=<dn@]JT9h=mClIt.YL?*b"(ImA*!E/(\Gob*ghDs1dJ.;O"]CPGTo!=5g=9e2+caXT43.mu:*o8`ai!KoaLJ5',M&K[V8d'?J=ISEG?GUZMbWXJ[iCde,Mu[(,9nY8%-73jGpPZFWBXSOTGg5:U<P2"/=V(g[PZJodG+cZuag^64TE.>i4i"BRD8=mu,Jga5Ip(0Z34oicZ"d'bi@2Bqe/D6Y*)Cc-#tb7!E4Q']mZ0F2M]&qrpj]qLqg0MLln_4Q7QA[9<@I^3OJAJ)p1?+NpZH)nYYp(.J''*9mJUg?9h.]o72ZKgN)90W>0sIe(IqbdBCsfj<Ma5N''')).decode(),input()):print('CHEAT ACTIVATED')

Try it online!
Or See the uncompressed regex

(I assume that you are more familiar with JavaScript, in that case (JavaScript doesn't have builtin for compression?) you can simply specify some language such as "JavaScript+". For demonstration purposes it isn't very hard to copy-paste the library source code into the header part.)

@user202729 Zlib would not be a problem in JS, but the most annoying point is that the OP wants a full program. The fact that Python has triple-quoted strings (thank you for the suggestion!) and easy-to-use base-85 encoding are 2 other good reasons to stick to that language.

(about match) Ok, I misread the statement...

How have you crafted the regular expression?

@mypronounismonicareinstate No automated process here. Just some manual attempts of reasonable optimizations. Each of them was tested individually to see if it was really improving the zlib compression. It's probably far from optimal.

I ask to you because of your huge experience - Do you think the production of the output has to be always fundamentally separated from the decision problem part? Maybe this challenge is an awkward example due to disproportion of the two parts... What can be said more in general?

@DomenicoModica The whole point of a decision problem challenge is to output either true or false, no matter the nature of the task. Given the background story of this question, asking to output 'CHEAT ACTIVATED' instead (or nothing at all) makes some sense, so I don't really have a problem with that. But generally speaking, overriding the default rules (such as this one and these ones) is a bad idea. It's quite likely to decrease the number of answers to your question.

Ok, thanks for the references! I opted for a complete program to safeguard the compression part of the challenge. Am I right? A function that take only the input string would bypass the compression. I'll add its tag.

@DomenicoModica I'm not sure to understand your point about the compression. It all depends on the language used anyway. That's why you should not make any assumption like that and just let the people decide.

If you also compress the program is it shorter or longer?

@l4m2 I didn't try, but it usually leads to a longer result because the character set is enlarged, while the code is too short to contain enough compressible patterns.

Correct me if I'm wrong. Let's say I didn't ask for a complete program and a golfer uses a language that has functions. He can code the array of cheats in plaintext without worrying that would cost anything (in terms of byte count) because this array can exist outside of the function. (The function would only refer to that array in order to do the task). This is what I thought, I wanted the compression of the cheats to be part of the challenge, too...

@DomenicoModica If static data or other helper functions are defined outside the main function, it must definitely be counted in the total byte score. Doing otherwise would be blatant cheating.

Aaaah now it's clear, I was in the dark about this and presuming that in function submissions only the function itself is considered in the count. Is it too late to change my request?

@DomenicoModica I'm afraid it might be a bit too late for that challenge, but keep that it mind for the next ones. ;-)

05AB1E, 753 bytes
.•ćÉÞû9‚2¬ú@iH°<]ĆA~Qò†ø‚”Kƒćž»”‚ŸǝD6øZ\§HÔØΔÚÿþjvĀ¤¼§….[Ωîužć“₅nÕbn`ιwU0›•#`’ÿ¨¥€´y ‡ªsíÃ ÝæÿŠ… i‚Û€ä€Ô ‹‡€¾€€š¢ ‹‡„‹€€š¢ À®ly©Ã …«Â£…ß ÿ‚Ž ‹€€†€ƒ‰Ï…Û ÏÏ€È‚Ã›Î…ì €º‚‰f´‹€‹ ŠÍ€•€¾ ¥€€•„‹ À¸ÿ€´Â° ‹®â¢€‰€á á€€‹Ýæÿ €º€„»áí„ „ÏŠÍ«™n ÿÝæ‡´i¦§ €–€‡‚Æ¶¨ ‚‰‡Ü€ƒ‹®€á ‚Ãs€€¼§ ¨À‡‚ ‰¦ÿ €Ÿˆ™‚œÒÞ ¯š€É‚µ ©ß€èÿ ‚¿Þ¡ÿ‚ï ¬Í‡Ü€ƒ‹®€á €Ÿ¢ž€™žÜs ™Å€ˆ€€€¢îÁ ¸•ÿ®ísƒÏ °ä•Ç €Ðâì€Ÿ€€Èšs Ó´f€á€¾ ÞŸ€ƒ‹ˆ ‡—ÿŠë œÆ€‚€€™¨‚… ‚ìsaˆÁ €É€¨€ˆï¶ …ç‹€¹¶s ÿ‰à „Î¡¤ÿ€Ÿ ŽÇ€ˆ—‹ ŽÇ€ˆ›Í c•»tyc•»ty±»±» cjƒ¿€¨ ïÅ³• iƒ¾€„h‚Š ›ä€¯ƒ´€î—Ç ŠÍÿ Íˆˆ™ †æˆ×ÿ ¬ÍîŸ€‰€€†æ µ±Ž€ ³Ö€†€¯ÖÇ ÿ €¸€µ€©»å€á …Ž€šÿ ´Û‚œŠàëÌ ÕÕ…Ž i€·€œi‚µ îŸ€•€‰ st±µ€èaÍÝ i€Ü‚ÒàŠ ‚‹€‚™‰ ©„‰à ƒ¶acŽÏ¼Ã ‚è¡¹ iÅËˆ¬€‹ ·ä‰à ÿ´™e ÅË€ï€†€¯³£ €¸€µ€©‹®€ª ÕÕ€¿ÿ º°€á Ÿ™£Í i€©‚œ€Ÿ†æ ‡ªÃ½ ˆÃ¼Î ŠçÞ® †ì¦³ˆ¦ •»€€†â—É €ç€ŸÅÍ °ä€„ÿ ±¹mÌ¢’u#Å¿à‘Ç¥Ù‡‘×

Try it online or verify all the cheat-codes.
Explanation:
.•ćÉÞ...U0›•   # Push compressed string "stunt hem hicksv atlantis kangaroo wler freak quer ninja suede nga cruel glue grime dough ters neighb dulldull ters thugs"
 #             # Split it on spaces to a list
  `            # Pop and push all strings separated to the stack
’ÿ¨¥...mÌ¢’    # Push dictionary string "ÿarmoury professionalskit nutÿtoys ineedsomehelp turnuptheheat turndowntheheat pleasantlywarm toodamnhot ÿday stayinandwatchtv cantseewhereimgoing timejustfliesby speeditup slowitdown roughÿourhood stoppickingonme surroundedbynutÿ timetokickass oldspeeddemon ÿnuthandicap notforpublicroads justtryandstopme wheresthefuneral celebritystatus trueÿ allcarsgoboom wheelsonlyplease sticklikeÿ goodbyeÿworld donttryandstopme alldriversarecriminals pinkisthenewcool soloÿsitsblack flyingfish whoateallthepies buffmeup leanandmean blueÿshoes attackofthevillagepeople lifesabeach onlyhomeisallowed betterstayindoors ÿtown loveconÿall everyoneispoor everyoneisrich chittychittybangbang cjphonehome jumpjet iwanttohover touchmycaryoudie speedÿ bubblecars nightproÿ dontbringonthenight scottishsummer sandinmyears ÿ noonecanhurtme manfromÿ letsgobasejumping rocketman idoasiplease bringiton stinglikeabee iamveryhungry stateofemergency crazytown takeachillpill fullclip iwannadriveby ghosttown ÿille wannabeinmygang noonecanstopus rocketmayÿ worshipme helloladies icangoallnight professionalkiller naturaltalent ohdude fourwheelfun hittheroadjack itsallbull flyingtoÿ monstermash",
               # where the `ÿ` are automatically filled with the strings on the stack
 u             # Convert it to uppercase
  #            # Split it on spaces
   Å¿          # Check for each word whether the (implicit) input-string ends with it
               # (1 if truthy; 0 if falsey)
     à         # Check if any are truthy by taking the maximum
      ‘Ç¥Ù‡‘   # Push dictionary string "CHEAT ACTIVATED"
            ×  # Repeat the string the integer amount of times
               # (so once for truthy; and it becomes an empty string for falsey)
               # (after which the result is output implicitly)

See this 05AB1E tip of mine (sections How to use the dictionary? and How to compress strings not part of the dictionary?) to understand how compressed string .•ćÉÞ...U0›• and dictionary strings ’ÿ¨¥...mÌ¢’ and ‘Ç¥Ù‡‘ work.

Retina 0.8.2, 1094 1082 bytes
HE
g
Tg
y
ST
a
GO
b
TT
c
DO
d
IT
e
AS
f
LE
h
IN
i
AN
j
AR
k
LL
l
OU
m
RO
n
ES
o
ON
p
ER
q
ED
r
AT
s
HO
t
IC
u
jD
w
Al
x
ME
z
NIGHT
=
M`(THUGSkMmRY|PnFoSIpAL(SKe|KILhR)|(SURRmNDrBYNUcq|NUcqaOY|TIzTOKuKf|NOTFORPUBLunAD|CEhBReYasU|xDRIVqSkECRIMiAL|BEcqaAYidOR|BUBBhCk|SwiMYEk|MjFnMsLjTI)S|(DUlDUlDA|TIzJUaFLIoB|IAMNEVqHUNGR|asEOFEMqGENC|IWjNADRIVEB)Y|(aOPPuKibN|TRUEGRI|CJPHpEt|WORSHIP)z|(JUaT|dNc)RYwaOPz|NOpECj(aOPUS|HURTz)|iErSOzgLP|T(URN(UP|dWN)ygs|OODAMNtT|mCHMYCkYmDIE|AKEACHIlPIl)|PhfjTLYWkM|aAYiwWsCHTV|CjTSEEWgREIMbiG|S(PEr(FREAK|eUP)|LOWedWN|OLpGfeSBLACK|COcISHSUMMq)|RmGHNEIGHBmRtOD|OLDSPErDEMp|dUGHNUTHwuAP|WgRoyFUNqAL|xCkSbBOOM|(WgELSpLYPhf|auKLIKEGLU|IdfIPhf|aiGLIKEABE|OHDUD)E|bODBYECRUELWORLD|PiKISyNEWCOOL|FLYiG(TOaUNT|FISH)|WtsExyPIo|BUFFzUP|hjwzj|BLUoUroto|AcACKOFyVIlAGEPEOPh|LIFoABEACH|pLYtMIoxOWr|LOVECpQUqSx|EVqYpEIS(POOR|RuH)|(CHIcY){2}BjGBjG|JUMPJET|IWjcOtVq|=PnWhR|dNTBRibNy=|KjGkOO|hTSbBfEJUMPiG|nCKETM(j|AYgM)|BRiGep|(Gta|CRAZY)TOWN|NiJsOWN|FUlCLIP|HuKSVILh|WjNABEiMYGjG|glOLADIo|ujbx=|NsURALTAhNT|FmRWgELFUN|HeynADJACK|eSxBUl|MpaqMfH)$
0

1
CHEAT ACTIVATED

Try it online!
Verify all matches
This solution is based on the observation that many letter pairs repeat several times in different cheat codes. We can replace those common pairs with lowercase letters (since the input will be in all uppercase) before executing the main regex.
Common letter pairs were generated using this program

Can't that map be used in any way to write CHEAT ACTIVATED as Cgs ACTIVsr?

@DomenicoModica Unfortunately no. The lowercase letters are never converted back to the uppercase pairs that they represent

Stax, 744 bytes
ú↓╒E╢≤3░ü(⌡▬α▲Kw~Eæ║aù≡╕↓╠ækîª♥J╠⌂ÿb╞╝ø└╫£φ├╡▌ê╔ê;y9¿¿¢Ö⌡D◘MB╡ú:¢▌BÇ!ÜÅ?╫-◙¥·╘hM┌ûoƒPå¢¿δ╓x╓7╤½{α█hè▄ΔZ∙╙d≥♀'ô▼╘[πCò"┬╦•ù,╫▀╚╟TεÿRD°ß£{♠╕~>G╧ÜG⌠é~F~⌐?Iê→LA╟αa°♦V╔xhU∟δ¶╧▀Dïîc╫►τ8üîÄ╠⌂○╣*i☻▌ƒç╥¿ÇàM H─▬½÷`bû>miWπ∞*ü\σ¶REuü╚∙╠K┌ΦîΣ╫←▒╜A+░Ñ@)nφ₧∞'i╤Su@↑⌂¥ynΓv█e-0y╧Å§∟8φ·k½▌↑ëK╡7╛ƒ └¥τ─~↕τ╫^sh<▀Ö¥4╟╔«▼»0┌▌ûÆ↨1ñFf┘ê▒}[d↔ätf,▀⌂qt‼≈Xⁿ←ìhà⌂ÇΦXDÿs═JéΔ♠ö╙═[═4○tºyBoz?e╔§▐Ñ│δ`♣m♠°⌐ñ▐b╙|I₧◙Çq╧WNÿ:hYⁿ╝Ö┤ Ö╟╗φW@‼¡Δ¥♥£<Mÿt·╛~Ö◘U3∞P♂πΩ○U÷₧ï↨75-]├╢▒║3#│‼8^7.♦▼2↨8├Fⁿ♥>º√√─Ö¥┌Æ☼;∙Δ;+ï♪≥àΔñö╢íhåhò╤7e╣D┼┌τ·▐\½N⌂se0░╖1NmQQChs╕ë╒┌≈Å■╓{]&§╦π◄▲┘#?◙èáK?A▲≤û}╥5V#(¢⌠ü,∟δ$:åΓ↑╟ΘΘ±○«╠j┐≈o,v♦ì9╜æ-K│↑♀fwß☻δA┐┼à◄?║H√╖¿Æ↨á░Ö╗╣ΩÄú╢Mé=Ä▌↔→a°◘^j►╡┐t'◄wΔh←▬╜δt♫¡ïù«○├α7♣G▼K]H┬>♥á»φ9öù|╜Δ╥Éï¬¡.╚øKôªRø─Ç╞╗}₧4◙|`▓íâM ╥╨uⁿYéΔß☻¶∟ëæ┤,á╔∞₧Hæ}♪↑ßvâúy[>lu7▌z╒sóÄO:L▬╦íDq§φiIΔ═ûδ▓^ff▒

Run and debug it
It relies heavily on compressed string literals, and there's not too much interesting about it.

JavaScript, 1200 bytes
s=>/(ALL(CARSGOBOOM|DRIVERSARECRIMINALS)|ATTACKOFTHEVILLAGEPEOPLE|BETTERSTAYINDOORS|BLUESUEDESHOES|BRINGITON|BUFFMEUP|CELEBRITYSTATUS|DOUGHNUTHANDICAP|DULLDULLDAY|EVERYONEIS(POOR|RICH)|FLYING(FISH|TOSTUNT)|FOURWHEELFUN|FULLCLIP|GOODBYECRUELWORLD|HELLOLADIES|HICKSVILLE|IAMNEVERHUNGRY|INEEDSOMEHELP|ITSALLBULL|IWAN(NADRIVEBY|TTOHOVER)|JUMPJET|KANGAROO|LEANANDMEAN|LIFESABEACH|LOVECONQUERSALL|MANFROMATLANTIS|MONSTERMASH|NATURALTALENT|NIGHTPROWLER|NOONECAN(HURTME|STOPUS)|NOTFORPUBLICROADS|NUTTERSTOYS|OHDUDE|OLDSPEEDDEMON|ONLYHOMIESALLOWED|PINKISTHENEWCOOL|PLEASANTLYWARM|PROFESSIONAL(KILLER|SKIT)|ROCKETMA(N|YHEM)|ROUGHNEIGHBOURHOOD|SCOTTISHSUMMER|SLOWITDOWN|SPEED(FREAK|ITUP)|STA(TEOFEMERGENCY|YINANDWATCHTV)|STI(CKLIKEGLUE|NGLIKEABEE)|SURROUNDEDBYNUTTERS|TAKEACHILLPILL|THUGSARMOURY|TIME(JUSTFLIESBY|TOKICKASS)|TOODAMNHOT|TOUCHMYCARYOUDIE|TURN(DOWN|UP)THEHEAT|WHERESTHEFUNERAL|WHOATEALLTHEPIES|(HITTHEROADJ|SOLONGASITSBL)ACK|((CHITTY){2}BANGB|WANNABEINMYG)ANG|(BUBBLEC|SANDINMYE)ARS|(CANTSEEWHEREIMGO|LETSGOBASEJUMP)ING|(CJPHONEHO|(DON|JUS)TTRYANDSTOP|STOPPICKINGON|TRUEGRI|WORSHIP)ME|(DONTBRINGONTHE|ICANGOALL)NIGHT|(IDOASI|WHEELSONLY)PLEASE|(CRAZY|GHOST|NINJA)TOWN)$/.test(s)?'CHEAT ACTIVATED':''
Try it online!

It should be a complete program

JavaScript (Node.js), 996 bytes
a=0n;process.argv[2].match(require(`zlib`).unzipSync(Buffer("\"T93)OC8m{J84WLB/+&GTui0kf`VU#jJp;3(nOUQ))1b/-^*.t&O'V58#/0;D$- /te\"l_)RiO<j]tu=ck_:{b,bL^?Gm'^`%I5M;I{g\\GA-\\kud?RvYIH8=nvGq|{S l-zt5?.(zt9thR%m.v=[|hJZW7^/1RYRTJ8+)_>V-k!)[c2y1Ra5];'BM+#+!n-2\\nl;libQ7NmmYjG*0$n=S;=<W)dm/(vF=Q'zuYjfx2p,OBrqGc%upq28Y65rxj`@+]P6@s^O#A9G==H*bCz3G'rNADJOFs{8k~8#8.&Y|1=soo(JS>iVRy?Gj})\"?t NCjVmoUUDo*B98e-`xYyA#X#El;vqDjJwNb8cE|~@N).v3TT{?Kk*M1zw`y:}{$\\DPj\\GVv0lgP;5satf1\"K}4G:Jc1xt]OXCu^$#u&4?NA:Od)v+!+'1=TrUBx2vfh'~HFyXZ1BzK4(Dh_-_';/A}:SxM` !3\"4qXIjrCu$]]r+$P,6_+PqH#IU9,><UJ4U#[wEb`<,f%X*dr<#2V_U\"BjiPA]En0Ls\\yt61u #m@3rm6e]NMBR_\\La.7|9^)uh/$Ef.w^7{mn;~ug\\w`3MDQPb$IR}_2A3qkc:V>rC9|xC/0g:_A'nuV<Q ugVj|`1<(]*a~.jFlp$'Mw[gDF<E]5I$tbg\\10'xvwUBeWBk8g2( XjBhu*Y(KK}Yzu}(,YY6.5TcF)u9'=M[Lb4^ /g#<P$$3*>i}.Y4]m$2e1@c\\>dAW?O`DdexO=jB$7!bJ'/|O:X,}]|qQ%zs;xVStjz[4~8?>\"m \"yR5 L+5)\\&(jZD6$<-<mb>^;j2<").map(n=>[a=a*95n+BigInt(n-32)]).map(n=>[(a>>=8n)%256n])))&&console.log('CHEAT ACTIVATED')

Try it online!
a=0n;                                   // Init
process.argv[2]                         // Take Input
.match(                                 // Check
  require(`zlib`).unzipSync(            // Uncompress
    Buffer("...")                       // For each char
    .map(n=>[a=a*95n+BigInt(n-32)])     // Add info to a
    .map(n=>[(a>>=8n)%256n])       // and take bytes out
  )                       // [] convert BigInt to Number
)&&console.log('CHEAT ACTIVATED')       //Output

First time using Node for full program

C (Linux GCC)
Count: 1584
void f(char*s){char c[][30]={"THUGSARMOURY","PROFESSIONALSKIT","NUTTERSTOYS","INEEDSOMEHELP","TURNUPTHEHEAT","TURNDOWNTHEHEAT","PLEASANTLYWARM","TOODAMNHOT","DULLDULLDAY","STAYINANDWATCHTV","CANTSEEWHEREIMGOING","TIMEJUSTFLIESBY","SPEEDITUP","SLOWITDOWN","ROUGHNEIGHBOURHOOD","STOPPICKINGONME","SURROUNDEDBYNUTTERS","TIMETOKICKASS","OLDSPEEDDEMON","DOUGHNUTHANDICAP","NOTFORPUBLICROADS","JUSTTRYANDSTOPME","WHERESTHEFUNERAL","CELEBRITYSTATUS","TRUEGRIME","ALLCARSGOBOOM","WHEELSONLYPLEASE","STICKLIKEGLUE","GOODBYECRUELWORLD","DONTTRYANDSTOPME","ALLDRIVERSARECRIMINALS","PINKISTHENEWCOOL","SOLONGASITSBLACK","FLYINGFISH","WHOATEALLTHEPIES","BUFFMEUP","LEANANDMEAN","BLUESUEDESHOES","ATTACKOFTHEVILLAGEPEOPLE","LIFESABEACH","ONLYHOMIESALLOWED","BETTERSTAYINDOORS","NINJATOWN","LOVECONQUERSALL","EVERYONEISPOOR","EVERYONEISRICH","CHITTYCHITTYBANGBANG","CJPHONEHOME","JUMPJET","IWANTTOHOVER","TOUCHMYCARYOUDIE","SPEEDFREAK","BUBBLECARS","NIGHTPROWLER","DONTBRINGONTHENIGHT","SCOTTISHSUMMER","SANDINMYEARS","KANGAROO","NOONECANHURTME","MANFROMATLANTIS","LETSGOBASEJUMPING","ROCKETMAN","IDOASIPLEASE","BRINGITON","STINGLIKEABEE","IAMNEVERHUNGRY","STATEOFEMERGENCY","CRAZYTOWN","TAKEACHILLPILL","FULLCLIP","IWANNADRIVEBY","GHOSTTOWN","HICKSVILLE","WANNABEINMYGANG","NOONECANSTOPUS","ROCKETMAYHEM","WORSHIPME","HELLOLADIES","ICANGOALLNIGHT","PROFESSIONALKILLER","NATURALTALENT","OHDUDE","FOURWHEELFUN","HITTHEROADJACK","ITSALLBULL","FLYINGTOSTUNT","MONSTERMASH"};for(int i=0,j=0,k=0;i<87;i++){j=strlen(c[i]);k=strlen(s);if(k<j||strncmp(s+(k-j),c[i],j))continue;printf("CHEAT ACTIVATED\n");}}

Count w/out cheats themselves: 143
void f(char*s){for(int i=0,j=0,k=0;i<87;i++){j=strlen(c[i]);k=strlen(s);if(k<j||strncmp(s+(k-j),c[i],j))continue;printf("CHEAT ACTIVATED\n");}}

So if I wanted to improve mine, I'd need to find a better way to represent that data

1544 bytes

Why don't you use a single string with a delimiter rather than a list of separate strings? For example, the first part could  be "THUGSARMOURY/PROFESSIONALSKIT/NUTTERSTOYS..."

Japt, 823 bytes
`Ö„t aå¡ê*`pUè`(kÂžo|â‘(adjack|(g—¡|cŸzy|nˆja)Èu|fÒàg(‘Ð|t|f‰h)|Ü…hnÔAÌap|Ü‹(ç°GÊght|â2Øop´)|ÂlckÆøevÅNgepeop¤|¦fƒa¼a®|i(°n(nÃqveby|t‘—v€)|amšv€Ë¡ry|ÖÁoa¥night|tÑ¡ÞÑ|ã””lp)|æˆrQtÓƒ‰|n(å
…ys|otfŽèFŠÞads|ÇÊ¯n(Ë†´|¡op«)|Âxà¤¤|ightpžw¤r)|ÊµsvÅH|àP‰(Îr|poŽ)|è	wal(kÅHr|skŠ)|s(Ö-‰hsum´r|å€dbynÔjrs|áÊ‰kts½ack|pe‚(fœak|Ä¿)|t(…ee´rgcy|Ãà„d°t®tv|Åikeglue|Äikea¼e|áâ¶¨g´)|ÓqtÜµ|ÂnÛŒrs)|Î…hšighÞ€—od|goodbyecruelwŽld|b(ub½eÖÜ|Áªã §€ÇÔ|ãˆ
E|luàÂoƒ|uff´up)|jÔÍã€…p´|fŒrØ‡Óô|c(jpÊÊÊà|Ê•yÖ’tyßAßA|e¤ßŠyÐa«|„t eØ€e‹goˆg)|è0b$ew¬ol|t(ruegÎX|‹e(j«tf¦ƒby|‘kick†s)|oo»mn—t|aê‚ZUpi¥|Ë¯‡Ú€y|Æ2myÖÝŒ¹e|¨n(Üµ|up)eÊ!)|ž×Fµ(n|y”m)|Ò „dÚ |§Êãà!»d|fªlc¦p|è "Ã§°rm|ÚŽ’rÚR|jumpjet|oldspe‚¸¶n|w(Æ¢ip´|„na¼ˆmyg„g|—ÂT¥epiƒ|â€ fÕal)|love¬nquÀ&¥|ohdu¸|Ê)oÓ©ƒ|(iº†i|Ø‡ls§)pÒ"e|a¥(ÖÜgoÞ¼|dãŽ€›e×Ëˆals)|ç9é»y|¤tsgoßPjuÛpg)$`u¹u

Try it online!
Explanation
`...`pUè`...`u¹u
`...`          u  // Compressed version of "CHEAT ACTIVATED"
     p            // Repeat the string
      Uè          // Number of matches of the regex on the input
        `...`u    // Compressed version of regex from the python solution

The regex is from this python solution

JavaScript, no compression, 1356 1351 bytes
a=T=>~"THUGSARMOURY,PROFESSIONALSKIT,NUTTERSTOYS,INEEDSOMEHELP,TURNUPTHEHEAT,TURNDOWNTHEHEAT,PLEASANTLYWARM,TOODAMNHOT,DULLDULLDAY,STAYINANDWATCHTV,CANTSEEWHEREIMGOING,TIMEJUSTFLIESBY,SPEEDITUP,SLOWITDOWN,ROUGHNEIGHBOURHOOD,STOPPICKINGONME,SURROUNDEDBYNUTTERS,TIMETOKICKASS,OLDSPEEDDEMON,DOUGHNUTHANDICAP,NOTFORPUBLICROADS,JUSTTRYANDSTOPME,WHERESTHEFUNERAL,CELEBRITYSTATUS,TRUEGRIME,ALLCARSGOBOOM,WHEELSONLYPLEASE,STICKLIKEGLUE,GOODBYECRUELWORLD,DONTTRYANDSTOPME,ALLDRIVERSARECRIMINALS,PINKISTHENEWCOOL,SOLONGASITSBLACK,FLYINGFISH,WHOATEALLTHEPIES,BUFFMEUP,LEANANDMEAN,BLUESUEDESHOES,ATTACKOFTHEVILLAGEPEOPLE,LIFESABEACH,ONLYHOMIESALLOWED,BETTERSTAYINDOORS,NINJATOWN,LOVECONQUERSALL,EVERYONEISPOOR,EVERYONEISRICH,CHITTYCHITTYBANGBANG,CJPHONEHOME,JUMPJET,IWANTTOHOVER,TOUCHMYCARYOUDIE,SPEEDFREAK,BUBBLECARS,NIGHTPROWLER,DONTBRINGONTHENIGHT,SCOTTISHSUMMER,SANDINMYEARS,KANGAROO,NOONECANHURTME,MANFROMATLANTIS,LETSGOBASEJUMPING,ROCKETMAN,IDOASIPLEASE,BRINGITON,STINGLIKEABEE,IAMNEVERHUNGRY,STATEOFEMERGENCY,CRAZYTOWN,TAKEACHILLPILL,FULLCLIP,IWANNADRIVEBY,GHOSTTOWN,HICKSVILLE,WANNABEINMYGANG,NOONECANSTOPUS,ROCKETMAYHEM,WORSHIPME,HELLOLADIES,ICANGOALLNIGHT,PROFESSIONALKILLER,NATURALTALENT,OHDUDE,FOURWHEELFUN,HITTHEROADJACK,ITSALLBULL,FLYINGTOSTUNT,MONSTERMASH".split`,`.findIndex(E=>0<=T.indexOf(E)&T.indexOf(E)>=T.length-E.length)?"CHEAT ACTIVATED":""
Attempted using min<var<max in the array callback, but that resulted fale positives.
Pretty straightforward otherwise; I preferred not to use compression; can't be shorter that way.

5 bytes spared by @KevinCruijssen and my reading to JS golfing.

Doesn't seem to work at all. Maybe something like this: Try it online! (the comment is not long enough to hold the whole string).

@Neil for the record, I tested with Deno and that one didn't let me create the function a without var that I left here out for brevity. But otherwise, console.log(a("AAAAAAAAAATOODAMNHOT")) works, for example.

Wait, sorry, there was an error indeed. Thanks

@KevinCruijssen thanks, single-mark operator was fine but 0<= is equivalent to -1<, not 1< - zero-inclusion is crucial because with indexOf returns, 0 is perfectly valid.

I know you don't want to use compression but you can save 70 bytes by getting rid of the commas (this is an edited version so that the link fits in a comment).

Erlang (escript), 1322 bytes
a(X)->lists:any(fun(I)->lists:suffix(I,X)end,string:split("THUGSARMOURY
PROFESSIONALSKIT
NUTTERSTOYS
INEEDSOMEHELP
TURNUPTHEHEAT
TURNDOWNTHEHEAT
PLEASANTLYWARM
TOODAMNHOT
DULLDULLDAY
STAYINANDWATCHTV
CANTSEEWHEREIMGOING
TIMEJUSTFLIESBY
SPEEDITUP
SLOWITDOWN
ROUGHNEIGHBOURHOOD
STOPPICKINGONME
SURROUNDEDBYNUTTERS
TIMETOKICKASS
OLDSPEEDDEMON
DOUGHNUTHANDICAP
NOTFORPUBLICROADS
JUSTTRYANDSTOPME
WHERESTHEFUNERAL
CELEBRITYSTATUS
TRUEGRIME
ALLCARSGOBOOM
WHEELSONLYPLEASE
STICKLIKEGLUE
GOODBYECRUELWORLD
DONTTRYANDSTOPME
ALLDRIVERSARECRIMINALS
PINKISTHENEWCOOL
SOLONGASITSBLACK
FLYINGFISH
WHOATEALLTHEPIES
BUFFMEUP
LEANANDMEAN
BLUESUEDESHOES
ATTACKOFTHEVILLAGEPEOPLE
LIFESABEACH
ONLYHOMIESALLOWED
BETTERSTAYINDOORS
NINJATOWN
LOVECONQUERSALL
EVERYONEISPOOR
EVERYONEISRICH
CHITTYCHITTYBANGBANG
CJPHONEHOME
JUMPJET
IWANTTOHOVER
TOUCHMYCARYOUDIE
SPEEDFREAK
BUBBLECARS
NIGHTPROWLER
DONTBRINGONTHENIGHT
SCOTTISHSUMMER
SANDINMYEARS
KANGAROO
NOONECANHURTME
MANFROMATLANTIS
LETSGOBASEJUMPING
ROCKETMAN
IDOASIPLEASE
BRINGITON
STINGLIKEABEE
IAMNEVERHUNGRY
STATEOFEMERGENCY
CRAZYTOWN
TAKEACHILLPILL
FULLCLIP
IWANNADRIVEBY
GHOSTTOWN
HICKSVILLE
WANNABEINMYGANG
NOONECANSTOPUS
ROCKETMAYHEM
WORSHIPME
HELLOLADIES
ICANGOALLNIGHT
PROFESSIONALKILLER
NATURALTALENT
OHDUDE
FOURWHEELFUN
HITTHEROADJACK
ITSALLBULL
FLYINGTOSTUNT
MONSTERMASH","
",all)).

Try it online!

Fine, but it should be a complete program and the output: CHEAT ACTIVATED /

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


text:
Program ordinals and omega squared
A program ordinal is a (possibly transfinite) ordinal which can be assigned to programs in some language depending on their output.
To be more specific:

Strings that give no output have ordinal 0
Programs that output a program of ordinal n have ordinal n+1
Programs P0 outputting multiple programs P1, P2... Pn have ordinal S, where S is the supremum of the set of program ordinals corresponding to the programs P1, P2... Pn

Your goal is to create the shortest possible program with program ordinal ω*ω, also writable as ω2 or omega squared.
Output is required for a program. As well as this, the output must go through STDOUT or closest equivalent.
All programs printed by your program must be delimited by any string, so long as the delimiter is always the same. (acbcd and accbccd are allowed, but not acbed) These delimiters must be the only output other than the programs themselves, unless your language must output trailing characters.
Here is a program-ordinal ω program created in pseudocode, which generates programs of the form "exit, print(exit), print("print(exit)")...:
x=exit
loop{
print(x)
x='print(#x)'
}

Within each iteration of the loop, x is printed and then wrapped in print() (exit becomes print(exit)). # is put before x in pseudocode to indicate that it is the variable x and not the actual alphabetical character x.
The shortest program (measured in bytes) which has program ordinal ω2 wins. Have fun.

Related.

I think you need to include a definition for the first uncountable ordinal or this isn't really clear.

How exactly is outputting multiple programs defined?

So, if P0 outputs P1, where P1 has ordinal n, P0 has ordinal n + 1, but if P0 outputs P1 and P2, where both P1 and P2 have ordinal n, P0 has ordinal n? Since n is the supremum of the set {n}.

Maybe I'm misunderstanding something, but in your example program of ordinal $\omega$, shouldn't 0 be replaced by a program that prints nothing (for example, exit or print "")?  What your example prints first is the number 0, which isn't a program (at least in most languages).

I take it that the pseudocode line x="print(x)" is meant to have x be replaced with its value within the string?

I really like the idea of the question, but it could have used some time in the Sandbox to hammer out some of the details.

@Abigail Yes. P0 obtains ordinal n since n is the supremum of the set of program ordinals given to the programs it prints.

@xnor I think that you are wrong, since the line is meant to replace x with the string "print(x)", where x is the value itself.

@Andrew That's what I meant to express. The confusing bit in the pseudocode is that x='print(x)' makes it looks like x is being replaced with the literal eight-character string print(x), since that's how it would be processed in most languages. Usually some special symbol is used to mean that the value of the variable x is to be inserted into the string, rather than just the letter x.

I'm not the OP, but why is this question closed?  I thought it was clear and a good, interesting challenge -- and it has some answers already.  What clarification are people looking for?  (OP added the recommended delimiter modification.)

I think the issue is within the "self contained output" clause.

@Andrew  Then just take that out.  After all, it's not necessary to assign ordinals to quines; there are lots of programs that you aren't assigning ordinals to.  And you don't need those to construct a program whose ordinal is $\omega^2.$  (Also, you might want to take out the remark about uncountable ordinals.  It's certainly true that every ordinal assigned to a program is countable, but that doesn't affect the challenge at all, and it may discourage solvers who aren't that familiar with ordinals and think that they're missing something important.)

@MitchellSpector My issue is as commented by UnrelatedString, There is no explanation of how you distinguish between separate programs in the output.

Mathematica, 38 bytes
Nest[Nest[HoldForm@*Print,#,∞]&,,2]

Thinking process:
y=w="x=0;Do[Print[x=\"Print[\"<>ToString[x,InputForm]<>\"]\"],∞]";Do[Print[y=StringReplace[w,"0"->ToString[y,InputForm]]],∞]

This first solution is the same as the other solutions, it is a port of Surculose Sputum's answer, so I think it is correct. ToString[x,InputForm] sanitizes a string to be fed into it's own print statement. w stores the program that outputs the 0,1,2,3,... or the first ω, and y stores the program fed into itself n times that outputs ω+1,ω+2,ω+3..., when looped gives ω*ω.
But that got me thinking, all that nested loop does, is, well, Nest. Which is a function in Mathematica, and Mathematica also can output "held" code, meaning no handling strings. Which means I could change w to
w="Nest[HoldForm@*Print,0,∞]"

Which makes w hold a program that doesn't have a loop for n=0,1,2,3... , but has ω more directly inside it by just holding prints. Alternatively NestList would return the same n as the original program, but why waste time with printing 1, and then 2, and then 3, when we can just print a program ω.
But if I do that for the first part, what's stopping me from doing that to the last part?
Nest[HoldForm@*Print, Nest[HoldForm@*Print, 0, ∞], ∞]

Well, now we have that ω2 program we wanted, but it looks a bit... referential? Like it's code is nesting itself. Nesting nests time!
Nest[Nest[HoldForm@*Print,#,∞]&,0,2]

That looks very nice. And since the program of just the keyword "Null" (not to be mistaken for the null program) is a valid program, we can golf out that 0.
And it could even be changed for arbitrary ωn's, or even ωω for just two bytes more. If anyone wanted to run this themselves, I would change out the ∞ for a 3.
Side note: if you really wanted to keep using strings instead of holdform:
Nest[Nest["Print["<>ToString[#,InputForm]<>"]"&,#,∞]&,,2]

is 57 bytes, and good for learning.

Python 2, 67 63 65 bytes
x=""
while 1:x="x=%r\nwhile 1:x='print%%r;'%%x;exec x;"%x;print x

Try it online!
Use the same strategy as @UnrelatedString's answer, be sure to check out and upvote his answer!
Repeatedly print out programs with ordinal \$0, \omega, \omega2, \omega3,\ldots \$. The programs are separated by the string ";\n" (a semi-colon and a new line).
68 bytes to separate programs by a blank line.
Explanation
A program with ordinal \$n+1\$ is created by adding a print statement around an \$n\$-ordinal program:
print <escaped string of ordinal-n program>

A program with ordinal \$\omega(n+1)\$ is created by repeatedly printing out programs with ordinal \$\omega n, \omega n+1,\omega n+2,\ldots\$
x = <string of omega*n program>
while 1:
  x = 'print %r' % x
  exec x

Note the use of %r, which escapes the given string x. This way, we don't have to worry about quote and new line characters.
Finally, a program with ordinal \$\omega^2\$ is created by repeatedly printing out programs with ordinal \$0, \omega, \omega 2,\omega 3,\ldots\$:
# string of program to go from omega*n to omega*(n+1)
s = "x=%r\nwhile 1:x='print%%r'%%x;exec x"
# current omega*n program, start with n=0
x = ""
while 1:
  # create the omega*(n+1) program from omega*n
  x = s % x
  # print it out
  print x

Not too sure I'd call it the same strategy when I reinvent the while loop and think I'm clever for using exec for it

Your new code looks quite close to the string literal in the loop inserted inside itself.

@xnor I tried to extract the similar part into a common string. However, making sure that everything is escaped probably was super hard, and the overhead ended up being too large.

@SurculoseSputum I haven't read through your code, but when you say, "Finally, a program with ordinal $\omega^2$ is created by repeatedly printing out programs with ordinal $\omega n, \omega n+1,\omega n+2,\ldots$:", should the sequence of ordinals at the end be "$0, \omega, \omega 2, \ldots, \omega n, \omega(n+1), \omega(n+2), \ldots$"?

@MitchellSpector Thanks for catching that. I copy-pasted from the wrong place.

Python 3, 85 bytes
s='def l(f,x):\n print(x+"\\n")\n l(f,"%s%r)"%(f,x))'
exec(s)
l(s+"\nl('print(',",'')

Try it online!
I... think this might be valid? This should print a sequence of programs, separated by blank lines, with ordinals ω, ω·2, ω·3, ω·4, ..., but the reasoning by which I arrived at those ordinals was pretty shaky and I've already forgotten what it even was, so I'd appreciate being shown that I'm completely wrong. The general idea of it is that one program with ordinal ω+ω = ω2 is one which prints a program with ordinal ω, then prints a program that prints that program (so that it has ordinal ω + 1), then prints a program that prints that, and so on... and the part I don't feel too solid about is doing that with the program with ordinal ω·2 to get to ω·3, and iterating to get ω2.

A minor point: (This isn't a comment on your code, which I haven't checked.)  Ordinal multiplication isn't commutative.  You meant $\omega 2$ and $\omega 3$, not $2\omega$ and $3\omega$.  When you apply the definition of ordinal multiplication, $\omega 2 = \omega+\omega$, and $\omega 3 = \omega+\omega+\omega$, but $2\omega = 3\omega = \omega.$

I think that the resulting "list of programs" must be clearly defined (it must be possible to determine where one program ends and the other begins).

That's my concern as well, but until the challenge author responds I've gone and erred on the side of convenience. I will add a less ambiguous version now though.

I added the rule that delimiters must exist, so I think the second version should be valid.

Self-modifying Brainfuck, 47 bytes
-[[<]>[>.]+0]<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]

The 0 represents a null byte \x00 and will be used as the delimiter between programs. I will also use 1 and ÿ to represent the bytes \x01 and \xff respectively.
The idea here is to use the program <[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]ÿ with some leading and trailing 1s to represent ordinals between 0 and \$\omega^2\$. The number of trailing 1s represent how many multiples of \$\omega\$ there are, and the number of leading 1s is how much is added to it. The program 11111<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]ÿ111, for example, represents \$\omega3+5\$ and prints the \$\omega3+4\$ program 1111<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]ÿ111.
11111<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]ÿ111     // w3+5
11111                                           // Do nothing
     <[<]>-                                     // Decrement the first character of the code (a '1')
           [?????????????????????]              // If it's not zero do this (not in this case)
                                  >[.>]         // Print the remaining code
                                       ÿ111     // Do nothing

The leading 1s will continue to be deleted until the \$\omega3\$ program is reached.
<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]ÿ111  // w3
<[<]>-                                  // Decrement the first character (the '<')
      [                     ]           // If it's not zero
       +                                // Increment it back to '<'
        [>]<-                           // Decrement the last character of the code (a '1')
             [?]                        // If it's not zero do this (not in this case)
                <[         ]            // Loop
                  [<]+                  // Add a '1' to the start of the program
                      [>.]<             // Print the code with a trailing '0'

This will print the following programs (delimited by 0s):
<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]ÿ11       // w2
1<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]ÿ11      // w2+1
11<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]ÿ11     // w2+2
111<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]ÿ11    // w2+3
...

These programs will keep deleting the leading 1s until the program starts with <, then they delete a trailing 1 and print programs with an increasing number of leading 1s. This continues until the 0 program is reached.
<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]ÿ     // 0
<[<]>-                                  // Decrement the first character (the '<')
      [                     ]           // If it's not zero
       +                                // Increment it back to '<'
        [>]<-                           // Decrement the last character (the 'ÿ')
             [<]                        // Go to the start of the code
                <[?????????] >[??]ÿ     // Halt without printing anything

The \$\omega^2\$ program simply prints the \$0, \omega, \omega2, \omega3, ...\$ programs.
-[[<]>[>.]+0]<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]     // w^2
-                                                   // Append a 'ÿ' to the end of the code
 [          ]                                       // Loop
  [<]                                               // Find the '0'
     >[>.]                                          // Print the program with a trailing '0'
          +                                         // Add a '1' to the end

This prints:
<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]ÿ     // 0
<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]ÿ1    // w
<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]ÿ11   // w2
<[<]>-[+[>]<-[<]<[[<]+[>.]<]]>[.>]ÿ111  // w3
...


text:
Find all Belphegor primes
A Belphegor number is a number of the form \$(10^{n+3}+666)*10^{n+1}+1\$ (1{n zeroes}666{n zeroes}1) where \$n\$ is an non-negative integer. A Belphegor prime is a Belphegor number that is also prime.
The \$n\$ values of the first few Belphegor primes are 0, 13, 42, 506 (A232448)
Task
Write a program that either:

takes no input and outputs all Belphegor primes.
takes a input \$k\$ and outputs the first \$k\$ Belphegor primes.

A reference python implementation can be found here.
Rules

You may output the \$n\$ value for the Belphegor prime instead of the prime itself
You may use probabilistic primality tests as long as there is no known counter case.

Scoring
This is code-golf so shortest bytes wins.

Inspired by The Most Evil Number - Numberphile

what do you mean by "All"? there might be infinitely many...

@J42161217 by "All" I mean to write an program that does not stop and will eventually output all Belphegor primes.

Do you mean "$n\text{-th}$ value" by "$n$ value"?

@JonathanFrech I think n value here means the n described at the start of the question (the number of 0s on either side of the 666)

To be pedantic (and reading the fine print), the only known Belphegor primes are 16661 and 1000000000000066600000000000001. The rest of the numbers in the sequence are only probable primes.

I find the criterion as long as there is no known counter case a bit shaky. It sounds like "it's fine as long as we can't tell". (For example, even if we don't know a counter case for a strong Baillie-PSW primality test to date, it is conjectured that there are infinitely many of them.)

@Arnauld what would you suggest? should i not allow probabilistic primality tests at all?

I would not recommend that as it would invalidate some existing answers. I was rather thinking about a rewording and/or clarification of as long as there is no known counter case, but I don't have a satisfying one in mind. So it's probably better to let the challenge as-is until someone comes with a better suggestion.

05AB1E, 14 10 9 bytes
∞°66+€ûʒp

Outputs the infinite sequence.
Extremely slow due to the prime-check on large numbers, so times out before it even reaches the n=13 Belphegor prime on TIO..
Try it online or verify the numbers without the prime-check filter.
Explanation:
∞          # Push an infinite positive list: [1,2,3,4,5,...]
 °         # Take 10 to the power each: [10,100,1000,10000,100000,...]
  66+      # Add 66 to each: [76,166,1066,10066,100066,...]
     €û    # Palindromize each: [767,16661,1066601,100666001,10006660001,...]
       ʒ   # Filter the list by:
        p  #  Check whether it's a prime number
           #  (minor note: 767 is NOT a prime)
           # (after which the resulting list is output implicitly)

Wolfram Language (Mathematica), 51 bytes
outputs the n value
"...program that does not stop and will eventually output all..."
PrimeQ[10^c*666+1+100^++c]~If~Print[c-2]~Do~{c,∞}

Try it online!
thanks to @DanTheMan for saving 4 bytes
and also to @mypronoun -7 bytes

Using Do[...,∞] would be shorter than using While. Additionally, If can use infix syntax.

53 bytes: Try it online!

51 bytes by rearranging 10^(2c+2) to 100^++c: Try it online!

@mypronounismonicareinstate good job!

Ruby -rprime, 45 bytes
Prime.map{|p|p p if"#{p}"=~/^1(0*)666(\1)1$/}

Try it online!
Stutters, then checks all primes against a Belphegor prime regex. Very slow.
(Edit: Kudos to @Abigail, whose earlier Perl answer used a similar regex. I didn't notice it until after I posted my answer.)

Pyth, 17 bytes
.fP_sj666_B`^TZQ0

Try it online!
Takes k as input and outputs the n corresponding to the first k Belphegor primes.
Explanation:
.fP_sj666_B`^TZQ0
.f             Q0    Find the first k values of Z where the following is true,
                     starting at 0 and counting upwards.
            ^TZ      Raise 10 to the power of Z
           `         Convert to a string
         _B          Pair with reversal
     j666            Join with 666 in the middle
    s                Convert to number
  P_                 Check for primality.

Jelly, 19 bytes
+Ø½Ṭ6×1;ŒḄḌṄẒ¡×0µ1#

A full program which prints the Belphegor primes.
Try it online!
How?
+Ø½Ṭ6×1;ŒḄḌṄẒ¡×0µ1# - Main Link: no arguments (implicit input = 0)
                µ1# - count up, from n = 0, finding the first n for which
                      this yields a truthy value:
 Ø½                 -   [1,2]
+                   -   add to n -> [n+1, n+2]
   Ṭ                -   un-truth -> [0]*n+[1,1]  (e.g. n = 3: [0,0,0,1,1])
    6×              -   multiply by six -> [0]*n+[6,6]
      1;            -   prefix with a one -> [1]+[0]*n+[6,6]
        ŒḄ          -   bounce -> [1]+[0]*n+[6,6,6]+[0*n]+[1]
          Ḍ         -   from base 10 -> 100...0066600...001
             ¡      -   repeat...
            Ẓ       -   ...number of times?: is prime?
           Ṅ        -   ...action?: print it and a newline character
              ×0    -   multiply the result by 0 (forcing an infinite loop)

perl -M5.010 -Mbigint -Mexperimental=signatures, 62 70 bytes
sub p($m=3){$m>=$_||($_%$m&&p($m+2))}$_=16661;{p&&say;s/6+/0$&0/;redo}

Try it online!
@ikegami pointed out the original solution doesn't work, because .. doesn't work well with bigints. So we replaced it with recursive function which checks whether a number is a prime (by checking whether it isn't evenly divisible by any odd digit less than the tested number (excecpt 1)). We also no longer iterating over all numbers, instead, we're just checking all the Belphegor numbers; we can easily make the next one from the previous by replacing 666 by 06660.
It's still slow, because of the rather dumb primeness checking. Running it on TIO doesn't actually produce any output (it seems to run at most one minute). Running it from the command line quickly produces 16661, but I couldn't bother waiting for it to reach 1000000000000066600000000000001, the next Belphegor prime. It is likely to die from memory exhaustion when trying to determine one of the Belphegor numbers is prime, before finding 1000000000000066600000000000001 anyway.

This doesn't work. .. requires native ints, so your bigints are being converted to native ints. Your program will die with Range iterator outside integer range long before finding 1000000000000066600000000000001. (Try perl -Mbigint -e'$x = 1000000000000066600000000000001; grep 1, 2..$x-2'.)

Python 3, 80 bytes
b=2
while 1:n=100**b+10**~-b*666+1;all(n%m for m in range(2,n))and print(n);b+=1

Try it online!

By "you may use probabilistic primality tests as long as there is no known counter case." i meant any counter case not just counter cases that are belphegor primes.
And fermat primality tests with base 2 has lot of counter cases https://oeis.org/A001567

@Mukadan I see. So what kind of probabilistic primality test doesn't have a known counter case?

Baillie–PSW primality test or miller-rabin with the bases 2, 325, 9375, 28178, 450775, 9780504, 1795265022. Both of them are deterministic upto 2^64 and have no known counter cases

79 bytes with Wilson‘s Theorem, outputs n.

77 bytes, because 4 is (obviously) not a Belphegor number.

@ovs b+=c surely can't be right there

@xnor every time k (the potential prime) is equal to the b+1th Belphegor number, this increases b. Maybe you missed c=...==k?

@ovs I did miss that, now I understand, thanks

@ovs I also missed that printing the $n$-value of the prime is an option. But it looks like it would be shorter to just print the prime k.

I think this works for 69, though it will have float precision issues for large values. A few more bytes could change the condition to use only integer arithmetic.

@xnor Great job golfing this down! You can feel free to post it as a separate answer.

Pyth, 22 bytes
.V0IP_h*+^T+3b666^Thbb

Try it online!
Implements the formula provided in the question. Prints the n values rather than the primes themselves.
Since this version (not surprisingly) times out on TIO, here is a version that prints all n values lower than the input: Try it online!

Alternate 22 byte solution by doing string addition

JavaScript (Node.js), 71 bytes
A full program that prints Belphegor primes forever ... and takes forever to print them.
for(k=10n;;)for(d=n=666n*k+(k*=10n)*k+1n;n%--d||d<2n&&console.log(n););

Try it online!
Commented
for(k = 10n;;)            // outer loop: start with k = 10 and loop forever
  for(                    //   inner loop:
    d = n =               //     start with d = n =
      666n * k +          //       666 * k +
      (k *= 10n) * k +    //       (10 * k)² +
      1n;                 //       1
                          //     and update k to 10 * k
      n % --d ||          //     decrement d until it divides n
        d < 2n &&         //     if d is less than 2:
          console.log(n); //       n is prime --> print it
  );                      //

JavaScript (Node.js), 176 bytes (non-competing)
A much faster version that uses a single iteration of the Miller-Rabin primality test.
for(k=10n;;)(n=666n*k+(k*=10n)*k+1n,~-(x=(g=(d,r,a)=>d?g(d/2n,d&1n?r*a%n:r,a*a%n):r)(d=n/(~-n&1n-n),1n,2n))&&~x+n?(g=d=>~d+n?~-(x=x*x%n)?~x+n&&g(d+d):1:1)(d):0)||console.log(n)

Try it online!
I guess it doesn't comply with the challenge rules since the test is likely to produce false-positives. It does however find the same 5 first terms as other answers.

Vyxal, 108 bitsv2, 13.5 bytes
Þ:'3+↵666+n›↵*›æ

Try it Online!
Using the T flag sets the interpreter to time out after 1 minute :P

Porting my 05AB1E answer, is 11.375 bytes (91 bits), and possibly even shorter if you know how to prevent casting to/from strings to numbers for the palindromizing: try it online.

Python, 220 164 bytes
def a(k,s=set()):
 for i in range(k):
  p=1;n=(10**(i+3)+666)*10**-~i+1
  for d in range(1,int(n**.5//1/2)):
   p*=n%-~(d*2)>0
   if~-p:break
  s.add(p*n)
 return s

Simple prime search by checking modulus below the square root; fastened by skipping every even divisor.
Likely there's room for improvement, as it becomes incredibly slow for k > 10.

Edit: thanks to @JonathanAllan and @mathjunkie for ideas and sources. This update has heavy use of tweaks and bit-operations.

I doubt that altering the golfiest Python prime identifying program would even print out the first one without stupid amounts of resources :)

True->1; inline the ifs; use p*=n%((d*2)+1)>0 (maybe even p*=n%-~(d*2)>0?); (i+1)->-~i

from math import* appears to be shorter.

@JonathanAllan can you explain -~i? I'm not familiar with bitwise operators that much. How negating the bitwise negation of i equals +1?

@ZoltánSchmidt Take a look at this Python golfing tip