It's August 10th, 2019, but your task still involves Y2K. Weird, right?

Create a program that, when run, prints itself, with a two digit number appended to it. The first time you run it, it should append 00 to its output (its source code, because this is a quine variant). When you run that output, the original program without a two digit number, it should output the original program, but with 01 appended to it.Run that output to get the OG program with 02 appended, then that to get the program with 03... This chain should continue until 99. That program should output "BREAKING NEWS: WORLD ENDS".

If your program is Y2Kparanoia: yes them:

1. It should output Y2Kparanoia: yes00
   


2. That output should print Y2Kparanoia: yes01
   


3. That output should print Y2K paranoia: yes02
   


4. Repeat until step 100: this program outputs the doomsday news specified

This is code golf, so the shortest program that can print itself while following these steps wins.

Go, 382 366 354 340 305 298 bytes

Won't win but I had fun with the challenge.

package main

import."fmt"

func main(){if n<199{s+="x60,"

Print(s[:147],s,100+(n/100)*(n%100+1))}else{Print("BREAKING NEWS: WORLD ENDS")}}

var s,n=`package main

import."fmt"

func main(){if n<199{s+="x60,"

Print(s[:147],s,100+(n/100)*(n%100+1))}else{Print("BREAKING NEWS: WORLD ENDS")}}

var s,n=`,1

Try it on the Go Playground!

Based on a quine. If the variable n is less than 199, then it adds to the string variable n a grave accent (x60), Go's character for multiline strings, followed by a comma ,. It continues by printing the first 147 characters of s (to prevent printing the , because that only occurs at the end) then prints s as a whole, and finally prints 100 if n == 1 and n+1 otherwise. The result is that successive runs change the variable n at the end of the program to 100, 101, etc. If the variable n is 199 or more, then it prints breaking news.

Ruby, 158 154 bytes

EDIT: Saved a pair of parens (and corresponding pair in the data section) by realizing that "BREAKING NEWS: WORLD ENDS" is a perfectly valid format string, and ruby ignores any extraneos parameters.

END{$><<(q=$s>198?"BREAKING NEWS: WORLD ENDS":%{END{$><<(q=$s>198?"BREAKING NEWS: WORLD ENDS":%%{%s})%%[q,$s<2?0:$s-99]}

$s=1%02d})%[q,$s<2?0:$s-99]}

$s=1

When starting this I realized that since the number has to go at the very end of the program, and ruby doesn't allow using variables before they are declared, I would have to make code run after the digits somehow. I could've done something like def a(s) ... end;a 1 which would become ...end;a 100, however using ruby's lesser-known END syntax uses fewer bytes. However, the block inside END is in a different scope, so $s must be a global variable.

Explanation:

• 
  END{ ... };$s=1: Run block of code just before program terminates; Set global variable $s to 1 (or to 100 - 199 in future iterations)


• 
  $><<( ... ): $> is a shortcut in ruby for stdout, and << on an IO writes to the IO. The parens are required, otherwise it becomes ($><<$s)>198...
  


• 
  

  $s>198?"BREAKING NEWS: WORLD ENDS":(q=...)%[q,$s<2?0:$s-99]: If I were to break this out into slightly more reasonable code it would be:

  
  
  

  if $s > 198
  
    "BREAKING NEWS: WORLD ENDS"
  
  else
  
    q = ...
  
    number_to_append = if $s < 2
  
      0
  
    else
  
      $s - 100 + 1
  
    end
  
    q % [q, number_to_append]
  
  end
  
  

  
  
  

  The % operator applied to a string is effectively printf, with the LHS being the format string and the RHS being the arguments.

  
  



• %{ ... (q=%%{%s}) ... $s=1%02d}: ruby has an interesting syntax for strings that also allows for pairs of curly brackets to appear within the string without any escaping as long as they are balanced. This is very helpful, as otherwise a similar quine would have to escape the string to put it into itself as a string literal. The two substitutions in the format string are %s for a regular string and %02d for a number right-padded to a size of 2 with the character 0.

Haskell, 240 232 218 bytes

p=putStr;h 1=100;h k=k+1;g _=p$"n="++show(h n);main|n>198=p "BREAKING NEWS: WORLD ENDS"|1>0=p<>print<>g$"p=putStr;h 1=100;h k=k+1;g _=p$"n="++show(h n);main|n>198=p "BREAKING NEWS: WORLD ENDS"|1>0=p<>print<>g$"

n=1

Try it online!

Adapted from a quine

Perl 6, 122 114 bytes

my&f={$^a;<print $a-199??"my&f={$^a;<$_>~~.EVAL};f "~($a-1&&$a-99)+100!!"BREAKING NEWS: WORLD ENDS">~~.EVAL};f 1

Try it online!

Takes the standard quine format and adds the breaking news string as well as the the function call with the appended number

I have no idea what I'm doing (how to check the size of this, for example), but here's some code that accomplishes the task.

a=input();print(*list(map(lambda x:f'Y2Kparanoia{x:02}n'if x<100else'BREAKING NEWS: WORLD ENDS',range(int(a),101))))

Let me know if I have to take this down and adjust it!