编写一个无限期运行的程序，以报告其当前正在运行的实例数量。程序的每个实例还应报告所有其他当前正在运行的实例中打开该程序的顺序。

例

用户启动程序的第一次-我们称这个实例1实例1的显示器1/1，因为它是第一个总的上马出实例1当前运行的实例。

在实例1运行时，用户第二次启动该程序以成为实例2。实例1现在显示1/2，是总共2个当前正在运行的实例中的第一个实例。实例2显示为，因为它是总共2个当前正在运行的实例中的第二个实例。2/2

假设用户继续生成更多实例，直到有5个实例为止。按照启动的顺序，它们的输出为：1/5 2/5 3/5 4/5 5/5。

现在，假设用户决定终止实例3，然后实例4成为新的实例3，实例5成为新的实例4，因为它们分别是已启动的第3和第4个实例（现在总数为4）实例。因此，每个实例的输出变化如下：

• 1/5 → 1/4
• 2/5 → 2/4
• 3/5 →（终止）
• 4/5 → 3/4
• 5/5 → 4/4

规则

• 您可以以任何合理的格式输出两个数字（实例号，实例总数）。
• 每当实例启动或终止时，所有其他实例必须在100毫秒内更新其各自的输出。
• 如果选择通过打印到新行（或其他“附加”输出格式；而不是替换）来更新输出，则必须仅在实例数更改时打印，而在其他任何时间都不要打印。
• 这是代码高尔夫。以字节为单位的最短程序获胜。
• 在您的答案中，建议您指定用户必须执行的操作才能打开多个实例，和/或录制截屏视频以进行演示。

APL（Dyalog Unicode），39字节^SBCS

匿名前缀功能。通过生成伪参数⍬（空数值向量）即调用f&⍬。使用来查询当前正在运行的线程，⎕TNUMS并使用来杀死一个或多个线程⎕TKILL n。线程在获得处理器时间后即立即立即输出[本机数量，总数]中的更改。

{⍵≡n←n[⍋n←⎕TNUMS~0]:∇n⋄∇n⊣⎕←n⍳⎕TID,⊢/n}

在线尝试！

{… } 匿名lambda ⍵参数在哪里（最初⍬是空的数值向量）

 n[… ] 索引n（待定义）：

  ⎕TNUMS~0 所有Ť hread 货号的BER除数0（REPL的）

   n← 存储为 n

   ⍋ 排列将升序排列

  现在我们有活动线程

  ⍵≡ 如果论点与此相同...

  : 然后：

   ∇⍵ 尾递归论证

  ⋄ 其他：

   ⊢/n 最右边的线程号

   ⎕TID, 此Ť hread的ID（螺纹数）加在多数

   n⍳ 找到ɩ这两个的ndices

   ⎕← 将其打印到STDOUT

   n⊣ 抛弃赞成 n

   ∇ 对此递归

Python 3中，694个 691字节

main.py

from requests import post as u
from _thread import*
import os
os.system("start cmd /C python s")
def l():
 def p(q):
  while 1:print(u(*q).text,end="\r")
 q=['http://localhost']
 q+=[u(q[0],'*').text]
 start_new_thread(p,(q,))
 input()
 u(q[0],'-'+q[1])
while 1:
 try:l();break
 except:0

s（server.py的缩写）

from bottle import*
from requests import post as q
try:
 q("http://localhost")
except:
 ids=["0"]
 @post('/')
 def _():
  content = request.body.read().decode('utf-8')
  if len(content)==0:return""
  if content[0]=="*":ids.append(str(int(ids[-1])+1));return str(ids[-1])
  elif content[0]=="-":del ids[ids.index(content[1:])]
  else:return str(ids.index(content)) + "/" + str(len(ids)-1)
 run(port="80")

为什么这么久？

不幸的是，该功能似乎并未内置在Python中。我很想使用多重处理，但这似乎并不适合我们正在做的事情（让用户从任何地方打开程序）。

因此，我接受了我所看到的StackOverflow帖子的建议（我放错了链接），并使用实现了它bottle。（我愿意接受新的建议）。

我使用了Bottle库来运行自己的微型http服务器，以便所有不同的实例都可以相互通信。我想我可以使用一个套接字，尽管我不相信这样做会减少字节数。

我有两个单独的文件，s和main.py。 s缺少服务器，并且因为它出现在代码中，所以我认为我应该使名称尽可能短。

通讯Web服务器的API

Web服务器仅接受POST请求，并且仅响应POST正文中的输入。

所有请求都通过/（或localhost/）。

有效输入：

• * 帖子正文中的，将请求服务器返回新ID来分配客户端。
• -<id> 帖子正文中的ID将从ID的活动列表中删除ID，从而减少所有相关ID和总数。
• 帖子正文中的空请求将仅返回一个空字符串。这是用于测试服务器是否在线的测试工具。

关闭程序

我实现了多线程，因此关闭程序就像按Enter一样简单。

打开程序

如果你没有正确的有你的环境变量中Python安装只需创建一个.bat文件，并把它放在同一个文件夹main.py，并s用下面的代码（如果您为所有用户安装了Python，它可能是在不同的位置）：

set PATH=%userprofile%\AppData\Local\Programs\Python\Python36
python main.py

学分

从694到691字节Adám。

sh + linux / unix工具，128字节

如果睡眠支持浮点数

trap '(flock 9;grep -vw $$ p>t;mv t p)9>l' exit;(flock 9;echo $$>>p)9>l;f(){ echo $(sed -n /^$$\$/= p)/$(wc -l<p);sleep .1;f;};f

否则，为159个字节

trap '(flock 9;grep -vw $$ p>t;mv t p)9>l' exit;(flock 9;echo $$>>p)9>l;perl -MTime::HiRes=usleep -nE/^$$'$/&&say("$./",$.+(@a=<>)),usleep 1e5,$.=-(@ARGV=p)' p

或可以用:（no-op）代替睡眠，但是它将使您积极等待。

Java 8，（199 + 301 =）500字节

M.jar ：（主程序）

import javafx.collections.*;class M{static ObservableList o=FXCollections.observableArrayList();static int j,F;int i,f;{F=0;ListChangeListener e=(ListChangeListener.Change c)->{if(f<1)System.out.println((F>0&i>F?--i:i)+"/"+j);};o.addListener(e);o.add(i=++j);}public void f(){F=f=i;j--;o.remove(--i);}}

S.jar ：（由服务器控制程序流）

import java.util.*;interface S{static void main(String[]a){List<M>l=new Stack();for(Scanner s=new Scanner(System.in);;){Float n=s.nextFloat();if(n%1==0)l.add(new M());else{int t=(int)(n*10-1);l.get(t).f();l.remove(t);}}}}

代码说明：

import javafx.collections.*;
                  // Required import for ObservableList, FXCollections, and ListChangeListener
class M{          // Program-class
  static ObservableList o=FXCollections.observableArrayList(); 
                  //  Static list to keep record of all instances
  static int j,   //  Static integer (total number of instances)
             F;   //  Static flag (remove occurred?)
  int i,          //  Non-static integer (id of this instance)
      f;          //  Non-static flag (has been removed)
  {               //  Non-static initializer-block (shorter than constructor)
    F=0;          //   Reset the static flag remove_occurred, because we add a new instance
    o.addListener((ListChangeListener.Change c)->{
                  //   Add a change listener for the ObservableList
                  //   This will monitor any additions or removes on the List
       if(f<1)    //    If this instance is not removed yet:
         System.out.println(
                  //     Print:
           (F>0&i>F?
                  //      If a removed occurred and this id is larger than the removed instance
             --i  //       Decrease its id by 1 before printing it
            :     //      Else:
             i)   //       Just print its id
           +"/"+j);
                  //      Plus the total number of instances left
    });
    o.add(        //   Add anything to the Observable list to trigger the listener
     i=++j);      //    Increase the total amount of instances, and set the id of this instance to the last one
  }               //  End of non-static initializer-block
  public void f(){//  Finalize-method
    F=f=i;        //   Set both flags to the current id
    j--;          //   Decrease the total amount of instances
    o.remove(--i);//   Remove the current instance from the list to trigger the listener
  }               //  End of Finalize-method
}                 // End of Program-class

import java.util.*;
                  // Required import for List, Stack and Scanner
interface S{      // Server-class
  static void main(String[]a){
                  //  Mandatory main-method
    List<M>l=new Stack();
                  //   List of programs
    for(Scanner s=new Scanner(System.in);
                  //   Create a STDIN-listener for user input
        ;){       //   Loop indefinitely
      int t=s.nextInt();
                  //    Get the next integer inputted
      if(t<1)     //    If it's 0:
        l.add(new M());
                  //     Startup a new program, and add its instance to the list
      else{       //    Else:
        l.get(t).f();
                  //     Close the program with this integer as id
        l.remove(t);}
                  //     And remove it from the list of programs
    }             //   End of loop
  }               //  End of main-method
}                 // End of Server-class

一般说明：

所有程序都将保留自己的ID记录；剩余实例总数；是否发生删除；以及哪些程序已关闭。

服务器只是启动和停止程序的包装器类。当用户输入时0，它将启动一个新程序。当使用的输入正整数（即2）时，它将使用该ID关闭程序。（注意：S.jar使用M.jar作为库来访问它。）

Gif实际效果：

进一步打高尔夫球的想法：

我只是在写说明时注意到，我仅将其ObservableList用于add / remove- ListChangeListener，而根本不使用其内容。删除它并使用其他类型的静态侦听器可能会更短。