Tulis program yang berjalan tanpa batas yang melaporkan berapa banyak contoh dari dirinya sendiri yang sedang berjalan. Setiap instance dari program juga harus melaporkan urutan pembukaan dari semua instance yang sedang berjalan lainnya.

Contoh

Pengguna meluncurkan program untuk pertama kalinya - kami akan memanggil Instance 1. Instance 1 ini ditampilkan 1/1, karena ini adalah instance pertama yang diluncurkan dari total 1 instance yang sedang berjalan.

Saat Instance 1 sedang berjalan, pengguna meluncurkan program yang kedua kalinya menjadi Instance 2. Instance 1 sekarang ditampilkan 1/2, menjadi instance pertama dari total 2 instance yang sedang berjalan. Instance 2 ditampilkan 2/2, karena ini adalah instance kedua dari total 2 instance yang sedang berjalan.

Katakanlah pengguna terus menelurkan lebih banyak contoh sampai ada 5 dari mereka. Dalam rangka peluncuran, output mereka: 1/5 2/5 3/5 4/5 5/5.

Sekarang, katakanlah pengguna memutuskan untuk menghentikan Instance 3. Instance 4 kemudian menjadi Instance 3 baru dan Instance 5 Instance 4 baru, karena mereka masing-masing adalah contoh ketiga dan keempat yang telah diluncurkan dari apa yang sekarang total 4 contoh. Jadi perubahan output setiap instance adalah sebagai berikut:

• 1/5 → 1/4
• 2/5 → 2/4
• 3/5 → (Dihentikan)
• 4/5 → 3/4
• 5/5 → 4/4

Aturan

• Anda dapat menampilkan dua angka (nomor contoh, jumlah total) dalam format apa pun yang masuk akal.
• Setiap kali sebuah instance diluncurkan atau diakhiri, semua instance lain harus memperbarui output masing-masing dalam waktu 100 milidetik.
• Jika Anda memilih untuk memperbarui output dengan mencetak ke baris baru (atau format output "tambahan" lainnya, bukan pengganti), Anda harus mencetak hanya ketika jumlah instance berubah, dan tidak pada waktu lain.
• Ini golf kode. Program terpendek dalam byte menang.
• Dalam jawaban Anda, Anda disarankan untuk menentukan apa yang harus dilakukan pengguna untuk membuka lebih dari satu contoh, dan / atau merekam screencast untuk diperagakan.

APL (Dyalog Unicode) , 39 byte ^SBCS

Fungsi awalan anonim. Panggil dengan menelurkan argumen dummy ⍬(vektor numerik kosong), yaitu f&⍬. Kueri menjalankan utas saat ini ⎕TNUMSdan bunuh satu atau beberapa utas dengan ⎕TKILL n. Output thread berubah dalam [nomor sendiri, jumlah total] segera setelah mereka mendapatkan waktu prosesor, yaitu cukup banyak secara instan.

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

Cobalah online!

{... } lambda anonim di mana ⍵argumen (awalnya ⍬, vektor numerik kosong)

 n[... ] indeks n(harus didefinisikan) dengan:

  ⎕TNUMS~0 semua T hread Bil bers kecuali nomor 0(REPL)

   n← simpan sebagai n

   ⍋ permutasi yang akan mengurutkan naik

  sekarang kami memiliki urutan utas aktif

  ⍵≡ jika argumennya identik dengan itu ...

  : kemudian:

   ∇⍵ Ekor berulang pada argumen

  ⋄ lain:

   ⊢/n nomor utas paling kanan

   ⎕TID, ini T hread ini ID (nomor benang) ditambahkan di bahwa

   n⍳ menemukan ɩ ndices dari dua

   ⎕← cetak itu ke STDOUT

   n⊣ Buang yang mendukung n

   ∇ ulangi itu

Python 3, 694 691 byte

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 (kependekan dari 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")

Kenapa begitu lama?

Sayangnya, fungsi ini tampaknya tidak dibangun ke dalam Python. Saya tergoda untuk menggunakan multi-pemrosesan, tetapi itu tampaknya tidak sesuai untuk apa yang kami lakukan (membiarkan pengguna membuka program dari mana saja).

Jadi, saya mengambil saran dari posting StackOverflow yang saya lihat (saya salah menempatkan tautan) dan saya mengimplementasikannya menggunakan bottle . (Saya terbuka untuk saran baru).

Saya menggunakan perpustakaan Botol untuk menjalankan server mini http saya sendiri sehingga semua contoh yang berbeda dapat berkomunikasi satu sama lain. Saya kira saya bisa menggunakan soket, meskipun saya tidak yakin itu akan mengurangi jumlah byte.

Saya punya dua file terpisah, sdan main.py. skekurangan server dan karena muncul dalam kode, saya pikir saya harus membuat nama sesingkat mungkin.

API Komunikasi Server Web

Server web hanya menerima permintaan POST dan hanya menanggapi input di dalam tubuh POST.

Semua permintaan melalui /(atau localhost/).

Masukan yang valid:

• * dalam postingan akan meminta server untuk mengembalikan id baru untuk menetapkan klien.
• -<id> dalam postingan akan menghapus id dari daftar aktif id, mengurangi semua id yang relevan dan jumlah total.
• Permintaan kosong di badan pos hanya akan mengembalikan string kosong. Inilah yang digunakan untuk pengujian untuk melihat apakah server online.

Menutup program

Saya menerapkan multi-threading sehingga menutup program ini semudah menekan enter.

Membuka program

Jika Anda tidak memiliki pengaturan Python dengan benar di dalam variabel lingkungan Anda cukup buat .batfile dan letakkan di folder yang sama dengan main.pydan sdengan kode berikut (jika Anda menginstal Python untuk semua pengguna, itu mungkin berada di lokasi yang berbeda):

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

Kredit

Dari 694 hingga 691 byte Adám .

sh + linux / alat unix, 128 byte

jika tidur mendukung angka floating point

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

jika tidak, 159 byte

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

atau tidur bisa diganti dengan :(tanpa op), tetapi itu akan membuat penantian aktif.

Java 8, (199 + 301 =) 500 byte

M.jar: (program utama)

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: (server untuk mengontrol aliran program)

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);}}}}

Penjelasan kode:

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

Penjelasan umum:

Semua program akan menyimpan id mereka sendiri; jumlah total contoh yang tersisa; apakah pemindahan terjadi; dan program mana yang ditutup.

Server hanyalah kelas pembungkus untuk memulai dan menghentikan program. Ketika pengguna memasukkan 0, itu akan memulai program baru. Ketika input yang digunakan bilangan bulat positif (mis2 ), itu akan menutup program dengan id itu. (Catatan: S.jar memiliki M.jar sebagai perpustakaan untuk mengaksesnya.)

Gif untuk melihatnya dalam aksi:

Pikiran untuk golf lebih lanjut:

Saya baru saja memperhatikan ketika menulis penjelasan bahwa saya hanya menggunakan ObservableListuntuk itu add / remove- ListChangeListener, dan tidak menggunakan kontennya sama sekali. Menghapus ini dan menggunakan jenis lain dari Pendengar statis mungkin lebih pendek.