अनिश्चित काल तक चलने वाला कार्यक्रम लिखें जो रिपोर्ट करता है कि वर्तमान में स्वयं के कितने उदाहरण चल रहे हैं। कार्यक्रम के प्रत्येक उदाहरण को उस क्रम की भी रिपोर्ट करनी चाहिए जिसमें इसे वर्तमान में चल रहे अन्य सभी उदाहरणों से खोला गया था।

उदाहरण

उपयोगकर्ता पहली बार प्रोग्राम लॉन्च करता है - हम इस इंस्टेंस 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 बन जाता है, क्योंकि वे क्रमशः तीसरे और चौथे उदाहरण हैं जो अब 4 के कुल से लॉन्च किए गए हैं उदाहरणों। तो आउटपुट में प्रत्येक उदाहरण का परिवर्तन निम्नानुसार होगा:

1/5 → 1/4
2/5 → 2/4
3/5 → (समाप्त)
4/5 → 3/4
5/5 → 4/4

नियम

आप किसी भी उचित प्रारूप में दो संख्याओं (उदाहरण संख्या, कुल उदाहरण) का उत्पादन कर सकते हैं।
जब भी कोई उदाहरण लॉन्च या समाप्त किया जाता है, तो सभी अन्य उदाहरणों को 100 मिलीसेकंड के भीतर अपने संबंधित आउटपुट को अपडेट करना होगा।
यदि आप एक नई लाइन (या अन्य "अपीयरिंग" आउटपुट फॉर्मेट के अनुसार, आउटपुट को अपडेट करने के लिए चुनते हैं; प्रतिस्थापन के विपरीत), आपको केवल तभी प्रिंट करना होगा जब इंस्टेंसेस की संख्या में परिवर्तन हो, और किसी अन्य समय पर नहीं।
यह कोड गोल्फ है। बाइट्स जीत में सबसे छोटा कार्यक्रम।
आपके उत्तर में, आपको यह निर्दिष्ट करने के लिए प्रोत्साहित किया जाता है कि उपयोगकर्ता को एक से अधिक उदाहरण खोलने के लिए क्या करना चाहिए, और / या प्रदर्शित करने के लिए एक स्क्रीनकास्ट रिकॉर्ड करना चाहिए।

code-golf stateful

— darrylyeo
स्रोत

टैग करने के लिए किसी के पास सुझाव हैं?

— darrylyeo

ऐसा कार्यक्रम ओएस-विशिष्ट होगा।

— user202729

क्या "जब भी कोई उदाहरण लॉन्च किया जाता है या समाप्त किया जाता है, तो अन्य सभी उदाहरणों को 100 मिलीसेकेंड के भीतर अपने संबंधित आउटपुट को अपडेट करना होगा" यहां तक कि हमारे नियंत्रण के भीतर भी कि हमें संचार करने के लिए ओएस पर निर्भर होना चाहिए (और तथ्य यह है कि हम बहुत से, कई प्रक्रियाएं कर सकते हैं) टी मदद)?

— जोनाथन एलन

@ ओरोस प्रक्रिया व्यवधान OS से स्वतंत्र नहीं हो सकता

— edc65

3

एपीएल (Dyalog यूनिकोड) , 39 बाइट्स ^SBCS

अनाम उपसर्ग फ़ंक्शन। डमी तर्क ⍬(खाली संख्यात्मक वेक्टर) पर स्पॉनिंग द्वारा कॉल करें , अर्थात f&⍬। क्वेरी वर्तमान में थ्रेड्स चला रही है ⎕TNUMSऔर एक या अधिक थ्रेड्स को मार सकती है ⎕TKILL n। थ्रेड्स का आउटपुट [स्वयं की संख्या, कुल संख्या] में बदल जाता है जैसे ही उन्हें प्रोसेसर का समय मिलता है, अर्थात बहुत अधिक।

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

इसे ऑनलाइन आज़माएं!

{... } अनाम लंबोदर जहां ⍵तर्क है (शुरुआत में ⍬, खाली संख्यात्मक वेक्टर)

n[… ] सूचकांक n(परिभाषित किया जाना है):

⎕TNUMS~0संख्या (REPL) को छोड़कर सभी T hread Num bers0

n← के रूप में स्टोर n

⍋ क्रमपरिवर्तन जो आरोही क्रमबद्ध होगा

अब हमारे पास सक्रिय धागे हैं

⍵≡ यदि तर्क उस के समान है ...

: फिर:

∇⍵ पूंछ तर्क पर पुनर्विचार

⋄ अन्य:

⊢/n सबसे सही थ्रेड नंबर

⎕TID, यह T hread की ID (थ्रेड नंबर) उसी से जुड़ा हुआ है

n⍳उन दो के the ndices खोजें

⎕← STDOUT पर प्रिंट करें

n⊣ के पक्ष में है कि त्यागें n

∇ उस पर फिर से पाटना

— एडम
स्रोत

2

पायथन 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")

यह इतना लंबा क्यों है?

दुर्भाग्य से, इस कार्यक्षमता को पायथन में नहीं बनाया गया है। मुझे मल्टीप्रोसेसिंग का उपयोग करने का प्रलोभन दिया गया था, लेकिन जो हम कर रहे हैं उसके लिए यह सही नहीं लगता था (उपयोगकर्ता को कहीं से भी प्रोग्राम खोलने की अनुमति देता है)।

इसलिए, मैंने एक स्टैकऑवरफ्लो पोस्ट की सलाह ली जिसे मैंने देखा (मैंने लिंक गलत किया) और मैंने इसका उपयोग करके लागू किया bottle। (मैं नए सुझावों के लिए खुला हूं)।

मैंने अपना खुद का मिनी http सर्वर चलाने के लिए बॉटल लाइब्रेरी का उपयोग किया ताकि सभी विभिन्न उदाहरण एक दूसरे के साथ संवाद कर सकें। मुझे लगता है कि मैं एक सॉकेट का उपयोग कर सकता था, हालांकि मुझे यकीन नहीं है कि बाइट की संख्या कम हो गई होगी।

मेरे पास दो अलग-अलग फाइलें हैं, sऔर main.py। sसर्वर की कमी है और क्योंकि यह कोड में दिखाई देता है, मुझे लगा कि मुझे यथासंभव छोटा बनाना चाहिए।

संचार वेब सर्वर का एपीआई

वेब सर्वर केवल POST अनुरोधों को स्वीकार करता है और केवल POST के शरीर के अंदर इनपुट के लिए प्रतिक्रिया करता है।

सभी अनुरोध /(या localhost/) से गुजरते हैं ।

मान्य इनपुट:

* पोस्ट बॉडी में क्लाइंट को असाइन करने के लिए नई आईडी को वापस करने के लिए सर्वर से अनुरोध करेगा।
-<id> पोस्ट बॉडी में आईडी की सक्रिय सूची से आईडी को हटा दिया जाएगा, जिससे सभी प्रासंगिक आईडी और कुल संख्या घट जाएगी।
पोस्ट बॉडी में एक खाली अनुरोध बस एक खाली स्ट्रिंग लौटाएगा। यह देखने के लिए परीक्षण के लिए उपयोग किया जाता है कि क्या सर्वर ऑनलाइन है।

कार्यक्रम को बंद करना

मैंने मल्टी-थ्रेडिंग लागू किया है इसलिए प्रोग्राम को बंद करना उतना ही सरल है जितना कि एंटर दबाना।

प्रोग्राम खोलना

यदि आपके पास अपने पर्यावरण चर के अंदर पायथन सेटअप सही ढंग से नहीं है, तो बस एक .batफ़ाइल बनाएं और उसे निम्न कोड के साथ main.pyऔर उसी फ़ोल्डर में sडालें (यदि आपने सभी उपयोगकर्ताओं के लिए पायथन स्थापित किया है, तो यह एक अलग स्थान पर हो सकता है):

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

क्रेडिट

694 से 691 बाइट्स Adám तक ।

— नील
स्रोत

क्या आप नहीं निकाल सकते :8080/?

— आदम डे

अगर मुझे पोर्ट 80 को पोर्ट आवंटित करना था, तो हाँ; अन्यथा, नहीं। वेबब्रोज़र्स (और अनुरोधों) के लिए डिफ़ॉल्ट पोर्ट 80 पोर्ट है, लेकिन मैं इसे हटा सकता हूं /।

— नील

@ Adám मैंने इसे पोर्ट परिवर्तन के साथ अपडेट किया, 1 बाइट को इस तरह बचाया।

— नील

1

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

या नींद को :(नो-ऑप) से बदला जा सकता है , लेकिन यह सक्रिय प्रतीक्षा करेगा।

— नहुएल फौलीउल
स्रोत

यह वास्तव में करीब है - "आपको केवल तभी प्रिंट करना होगा जब उदाहरणों की संख्या में परिवर्तन हो, न कि किसी अन्य समय में।"

— darrylyeo 16

@darrylyeo बस ठीक है, लेकिन कम समाधान की तलाश में था, लेकिन समय नहीं था, 100ms सोने के लिए भी, मेरे पास एक समाधान है, लेकिन अब

— नाहुले फौइउल

0

जावा 8, (199 + 301 =) 500 बाइट्स

एमजर: (मुख्य कार्यक्रम)

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

एसजर: (कार्यक्रम-प्रवाह को नियंत्रित करने के लिए सर्वर)

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

सामान्य स्पष्टीकरण:

सभी कार्यक्रम अपनी स्वयं की आईडी का रिकॉर्ड रखेंगे; शेष इंस्टेंसेस की कुल संख्या; चाहे कोई निष्कासन हुआ हो; और कौन से कार्यक्रम बंद हो गए हैं।

कार्यक्रम शुरू करने और रोकने के लिए सर्वर केवल एक आवरण-वर्ग है। जब कोई उपयोगकर्ता इनपुट करता है 0, तो वह एक नया प्रोग्राम शुरू करेगा। जब प्रयुक्त इनपुट एक धनात्मक पूर्णांक (यानी 2) होता है, तो यह उस आईडी के साथ प्रोग्राम को बंद कर देगा। (नोट: एसजर के पास इसे एक्सेस करने के लिए पुस्तकालय के रूप में एमजर है।)

कार्रवाई में इसे देखने के लिए:

आगे गोल्फ के लिए विचार:

मैंने सिर्फ ObservableListयह समझाते हुए लिखा कि मैं केवल इसके लिए उपयोग / हटाने- ListChangeListenerऔर इसके कंटेंट का उपयोग न करने के लिए करता हूं। इसे हटाना और दूसरे प्रकार के स्थिर श्रोता का उपयोग करना कम हो सकता है।

— केविन क्रूज़सेन
स्रोत

कितने उदाहरण चल रहे हैं?