~ ATH दुभाषिया लिखें

लोकप्रिय वेबकॉम होमस्टक एक प्रोग्रामिंग भाषा का उपयोग करता है जिसे ~ATHब्रह्मांडों को नष्ट करने के लिए कहा जाता है। हालांकि यह कोड गोल्फ चुनौती हमारे अस्तित्व को खत्म करने के लिए एक कार्यक्रम लिखने के लिए नहीं है, हम कुछ और tame (यद्यपि कम दिलचस्प) संस्थाओं को नष्ट कर देंगे: चर ।

~ATH(उच्चारण "टिल डेथ," ध्यान दें कि ~ath"टिल्ड एथलीट" कैसा होता है) एक वैरिएबल बनाकर काम करता है THIS, जिसके साथ एक कमांड निष्पादित होता है EXECUTE, और प्रोग्राम को पूरा करता है THIS.DIE()। होमस्टक में भाषा के उपयोग के लिए एक विकी पृष्ठ यहां पाया जा सकता है । इस चुनौती का लक्ष्य ~ATHदुभाषिया बनाना होगा ।

चुनौती के लिए, मैं कुछ विवरण बनाने जा रहा हूं ~ATHजो वास्तव में मौजूद नहीं हैं लेकिन इसे (कुछ हद तक) उपयोगी बनाते हैं।

भाषा केवल पूर्णांकों के साथ काम करेगी, जिन्हें साथ घोषित किया गया है import <variable name>;। चर स्वचालित रूप से 0. के मान पर सेट हो जाएगा। एक समय में केवल एक चर आयात किया जा सकता है।
एक चर xलेखन से कॉपी किया जा सकता bifurcate x[y,z];है, जो चर को नष्ट करेगा xऔर समान चर के साथ बदलने yऔर z। ध्यान दें कि यह हटाए गए नाम के समान चर नहीं बना सकता है। अनिवार्य रूप से, एक चर का नाम बदल दिया जाता है, फिर एक अलग नाम के साथ चर की एक प्रति बनाई जाती है। यह एक बेवकूफ सुविधा की तरह लगता है, लेकिन मूर्खता है बहुत गहरा जमा हुआ Homestuck में।
एक प्रोग्राम लिखने का सिंटैक्स जो कोड को निष्पादित करता xहै ~ATH(x){EXECUTE(<code>)}। यदि आप एक साथ दो चर पर कोड निष्पादित करना चाहते हैं, तो कोड नेस्टेड हो जाता है, जैसे ~ATH(x){~ATH(y){EXECUTE(<code>)}}:। सभी आदेशों में <code>दोनों पर निष्पादित किया जाएगा xऔर y।
अब आज्ञाओं पर चलते हैं। +1 से प्रासंगिक चर (ओं) को बढ़ाता है और -1. से घटाता है। और यह बात है।
इसकी अंतिम विशेषता ~ATHयह है कि यह जो भी काम करता है उसे मार देता है। चर को <name>=<value>कमांड में प्रारूप (एक नई पंक्ति के बाद) में मुद्रित किया जाता है [<name>].DIE();। बाद में, प्रोग्राम शब्द DIE <name>और एक नई पंक्ति को कई बार प्रिंट करता है , जो वैरिएबल के निरपेक्ष मान के बराबर होता है। जब चर एक साथ मारे जाते हैं [<name1>,<name2>].DIE();(आप जितने चाहें उतने चर मारे जा सकते हैं, तो जब तक वे मौजूद हैं), DIE()क्रम को चर पर क्रम से निष्पादित किया जाता है।

उदाहरण कार्यक्रम

कार्यक्रम 1:

import sollux;                  //calls variable "sollux"
import eridan;                  //calls variable "eridan"
~ATH(sollux){EXECUTE(--)}       //sets the value of "sollux" to -2
~ATH(eridan){EXECUTE(+++++)}    //sets the value of "eridan" to 5
[sollux].DIE();                 //kills "sollux", prints "DIE sollux" twice
~ATH(eridan){EXECUTE(+)}        //sets the value of "eridan" to 6
[eridan].DIE();                 //kills "eridan", prints "DIE eridan" 6 times

आउटपुट:

sollux=-2
DIE sollux
DIE sollux
eridan=6
DIE eridan
DIE eridan
DIE eridan
DIE eridan
DIE eridan
DIE eridan

कार्यक्रम 2:

import THIS;                    //calls variable "THIS"
~ATH(THIS){EXECUTE(++++)}       //sets the value of "THIS" to 4
bifurcate THIS[THIS1,THIS2];    //deletes "THIS", creates variables "THIS1" and "THIS2" both equal to 4
~ATH(THIS1){EXECUTE(++)}        //sets the value of "THIS1" to 6
[THIS1,THIS2].DIE();            //kills "THIS1" and "THIS2", prints "DIE THIS1" 6 times then "DIE THIS2" 4 times

import THAT;                                         //calls variable "THAT"
bifurcate THAT[THESE,THOSE];                         //deletes "THAT", creates variables "THESE" and "THOSE"
~ATH(THESE){~ATH(THOSE){EXECUTE(+++)}EXECUTE(++)}    //sets the value of "THESE" and "THOSE" to 3, then sets the value of "THESE" to 5
[THESE,THOSE].DIE();                                 //kills "THESE" and "THOSE", prints "DIE THESE" 5 times then "DIE THOSE" 3 times

आउटपुट:

THIS1=6
DIE THIS1
DIE THIS1
DIE THIS1
DIE THIS1
DIE THIS1
DIE THIS1
THIS2=4
DIE THIS2
DIE THIS2
DIE THIS2
DIE THIS2
THESE=5
DIE THESE
DIE THESE
DIE THESE
DIE THESE
DIE THESE
THOSE=3
DIE THOSE
DIE THOSE
DIE THOSE

यह कोड गोल्फ है, इसलिए मानक नियम लागू होते हैं। बाइट्स में सबसे छोटा कोड जीतता है।

code-golf interpreter

— आर्कटुरस
स्रोत

मृत्युपर्यन्त। आपने वहां क्या किया वह मैने देखा।

— डिजिटल ट्रॉमा

@DigitalTrauma मैं नाम के साथ आने के लिए एंड्रयू हुसी (होमस्टॉक लिखने वाला लड़का) को श्रेय देता हूं।

— आर्कटिकस

@sysreq ~ATHके लिए लाइन अंत के रूप में अर्धविराम का उपयोग करता है import, bifurcateऔर DIEआदेशों। REPL और फ़ाइलें दोनों ठीक हैं। इनपुट और आउटपुट दोनों में केस सेंसिटिविटी की आवश्यकता होती है (मैं वास्तविक से ~ATHयथासंभव मिलान करने की कोशिश कर रहा हूं )।

— आर्कटिकस

@sysreq मुझे कुछ चीजों को बदलना पड़ा ताकि भाषा वास्तव में वास्तविक जीवन में कुछ कर सके, मेरे द्वारा वर्णित pecs ठीक हैं।

— आर्कटुरस

मैं ईमानदारी से आश्चर्यचकित हूं कि इस सवाल ने अधिक प्रतिक्रियाएं नहीं दी हैं, और इससे भी अधिक आश्चर्य की बात है कि पर्ल जादूगरों के जादू की हथियारों से लैस पर्ल जादूगरों की कोई भीड़ नहीं है

— बिल्ली

जवाबों:

पायथन 2.7.6, 1244 1308 1265 1253 1073 1072 1071 1065 1064 1063 बाइट्स

ठीक है, मैं यहां कोई रिकॉर्ड नहीं तोड़ रहा हूं, लेकिन यह सबसे छोटा पायथन है, जो समय के साथ क्रमिक रूप से एक फ़ाइल से एक बार में इनपुट पढ़ने के रूप में इनफ़ॉफ़र जाएगा। मैं इसे बाद में एक अलग भाषा (और एक दुभाषिया, न कि केवल एक पार्सर) में एक-अप करने की कोशिश करूँगा। तब तक, घृणित भयानक राक्षसीता का आनंद लें।

नोट : tकार्यशील निर्देशिका में नामक एक फ़ाइल खोलता है । इसे कमांड लाइन तर्क खोलने import sysके लिए, फ़ाइल के शीर्ष पर जोड़ें और बदल 't'देंsys.argv[1]

n=s='\n';m=',';X='[';Y=']';c=';';A='~ATH';D='import';b,g,k=[],[],[];r=range;l=len;f=open('t','r').read().split(n)
def d(j,u):
 p=[]
 for e in j:
  if e!=u:p.append(e)
 return''.join(p)
for h in r(l(f)):f[h]=f[h].split('//')[0].split()
while[]in f:f.remove([])
for h in r(l(f)):
 i=f[h]
 if i[0]==D and l(i)==2and i[1][l(i[1])-1]==c and d(i[1],c)not in b:g.append(0);b.append(d(i[1],c))
 elif i[0].startswith(A):
  i=i[0].split('){')
  for e in r(l(i)):
   if i[e].startswith(A):
    i[e]=i[e].split('(')
    if i[0][1]in b:g[b.index(i[0][1])]+=(i[1].count('+')-i[1].count('-'))
 elif i[0].startswith('bifurcate')and l(i)==2and i[1][l(i[1])-1]==c:
  i=i[1].split(X)
  if i[0] in b:
   z=d(d(i[1],c),Y).split(m)
   for e in r(l(z)):g.append(g[b.index(i[0])]);b.append(z[e])
   g.remove(g[b.index(i[0])]);b.remove(i[0])
 elif i[0].startswith(X)and i[0].endswith('.DIE();')and l(i)==1:
  z=d(i[0],X).split(Y)[0].split(m)
  for e in r(l(z)):
   k.append((z[e],g[b.index(z[e])]))
for e in r(l(k)):k0=k[e][0];k1=k[e][1];s+=k0+'='+str(k1)+n+('DIE '+k0+n)*abs(k1)
print s

— बिल्ली
स्रोत

पायथन 2, 447 475 463 443 बाइट्स

exec("eNp1UUtrAjEQvu+vCEshiYnrxl7KbqOUVmjvCoUkxUdiG7BRkpW2iP3tTVwrReppMsx8r4l936x9A8JXoN5kmu/2WeCxK0KjrSu8mWmEs0Ad96YI27lDPu/1is7wKqcQ0kBLenM+ty0nilu4zqnPtYCSQcXL2P2LmNvl1i9mjWlBUhwKbRt14uhHjlSvjzVy1tqswO/7AjsSpKtwIpGvt2zALqyNnkf3k/FIolb2ACjlpe2jR6lk8fAUQbKNulx7YIF1IDkqwmZlGwQpxNXGW9cASyCHZKqFVVOCoJQOEhjxABKLO7N5QGmET5qOs/Qfoqq6TGUfb3ZlgKvOnOxTwJKpDq6HSLzsVfK1k7g1iB7Hd9/JWh3T9wclkYwTlY4odP0nnvk0C3RUwj95/ZUq".decode('base64').decode('zip'))

यह ज़िपिंग और एन्कोडिंग को चालू करता है प्रोग्राम बेस 64 अभी भी सामान्य संस्करण पर बाइट्स बचाता है। तुलना के लिए, यहाँ सामान्य है:

import sys,re
d={}
s=sys.stdin.read()
s,n=re.subn(r"//.*?$",'',s,0,8)
s,n=re.subn(r"import (.*?);",r"d['\1']=0;",s,0,8)
s,n=re.subn(r"bifurcate (.*?)\[(.*?),(.*?)\];",r"d['\2']=d['\3']=d['\1'];del d['\1'];",s,0,8)
s,n=re.subn(r"([+-])",r"\g<1>1",s,0,8)
s,n=re.subn(r"EXECUTE\((.*?)\)",r"0\1",s,0,8)
s,n=re.subn(r"\[(.*?)\]\.DIE\(\);",r"for i in '\1'.split(','):print i+'='+`d[i]`+('\\n'+'DIE '+i)*abs(d[i])",s,0,8)
n=1
s=s[::-1]
while n:s,n=re.subn(r"\}([+-01]*);?([^}]*?)\{\)(.*?)\(HTA~",r";\g<2>0+\1=+]'\3'[d;\1",s,0,8)
exec(s[::-1])

मूल रूप से "मैजिक के रेगेक्सी वैंड" समाधान जो वांछित था। स्टड से पूरे प्रोग्राम में एक ही स्ट्रिंग के रूप में पढ़ता है, पायथन अभिव्यक्तियों के साथ ~ ATH अभिव्यक्तियों को बदलता है जो वर्णित शब्दार्थ करते हैं, और परिणामी स्ट्रिंग को निष्पादित () करते हैं।

यह देखने के लिए कि यह क्या कर रहा है, अजगर कार्यक्रम को देखें, दूसरा प्रदान किया गया परीक्षण कार्यक्रम निम्नलिखित में अनुवाद करता है:

d['THIS']=0;                    
0+1+1+1+1;d['THIS']+=0+1+1+1+1+0;       
d['THIS1']=d['THIS2']=d['THIS'];del d['THIS'];    
0+1+1;d['THIS1']+=0+1+1+0;        
for i in 'THIS1,THIS2'.split(','):print i+'='+`d[i]`+('\n'+'DIE '+i)*abs(d[i])            

d['THAT']=0;                                         
d['THESE']=d['THOSE']=d['THAT'];del d['THAT'];                         
0+1+1;d['THESE']+=0+1+1+00+1+1+1;d['THOSE']+=0+1+1+1+0;    
for i in 'THESE,THOSE'.split(','):print i+'='+`d[i]`+('\n'+'DIE '+i)*abs(d[i])

यह अच्छी बात है कि 00 == 0: पी

जाहिर है, नियमों में अस्पष्टता का फायदा उठाकर कुछ बाइट्स को बचाया जा सकता है। उदाहरण के लिए, यह नहीं कहा जाता है कि उस स्थिति में क्या होना चाहिए जब कोई व्यक्ति DIE()एक चर की कोशिश करता है जो importएड नहीं किया गया है , या जो पहले से ही bifurcateडी है। विवरण के आधार पर मेरा अनुमान था कि कोई त्रुटि होनी चाहिए। यदि कोई त्रुटि की आवश्यकता नहीं है, तो मैं delबयान को हटा सकता हूं ।

संपादित करें: एक बग फिक्स्ड जो प्रदान किए गए परीक्षण मामलों के लिए परीक्षण नहीं किया गया था। अर्थात्, जिस तरह से यह था, हर ~ATHब्लॉक चर को बढ़ाने से पहले शून्य पर रीसेट करता है। इसे ठीक करने के लिए मुझे 28 बाइट्स खर्च करने पड़े। अगर किसी को ~ATHब्लॉक को बदलने का बेहतर तरीका दिखता है , तो मुझे यह जानना अच्छा लगेगा।

EDIT 2: रेगीक्स लूप को अनियंत्रित करके 12 बाइट्स बचाए गए, जिससे वे सभी सबन हो गए और कंप्रेशन को पुनरावृत्ति का ख्याल रखने दिया।

EDIT 3: forएक स्ट्रिंग गुणन के साथ आंतरिक लूप को प्रतिस्थापित करके 20 और बाइट्स सहेजे गए ।

— quintopia
स्रोत

अरे, आखिर जादू की रेग्जीन वैंड! मैं इसे हरा नहीं कर पाऊंगा लेकिन अच्छा किया है!

— बिल्ली

मेरा कार्यान्वयन नियमों द्वारा स्पष्ट रूप से कवर नहीं की गई चीजों को पूरी तरह से नजरअंदाज करता है, जिसका अर्थ है कि आपके लिए एक त्रुटि फेंकना ठीक नहीं है और बस उन मामलों को भी अनदेखा करें।

— बिल्ली

import sys,reइसके बजाय आप कुछ बाइट्स बचा सकते हैंimport sys;import re

— बिल्ली 11

वाक्य रचना हाइलाइटिंग यह पढ़ने में बहुत आसान बनाता है

— बिल्ली 18

@cat सॉरी मैं आपको इतना समय पहले कभी जवाब देना भूल गया था। आप इसे कमांड लाइन से चलाते हैं और इनपुट को फाइल से पाइप करते हैं:python ~ath.py < program.~ath

— क्विंटोपिया