अपनी भाषा बनाओ * ज्यादातर * अनुपयोगी (डाकू का धागा)

Question

इस टिप्पणी से प्रेरित ...

उपयोगकर्ता के लिए धन्यवाद कदम हेन , व्हीट-विजार्ड , और डेनिस को पोस्ट करने से पहले इस चुनौती के विनिर्देश को ठोस बनाने में मदद करने के लिए!

यह डाकू का धागा है! पुलिस के धागे के लिए, यहां जाएं

---

में इस चुनौती , आप कुछ कोड है कि चल रहे काम सौंपा जाता यह इतना अपनी भाषा नहीं रह संतुष्ट एक प्रोग्रामिंग भाषा जा रहा है के बारे में हमारी मानदंड है कि। उस चुनौती में, इसका मतलब है कि इसे बनाना ताकि भाषा अब और न हो ...

• संख्यात्मक इनपुट और आउटपुट लें

• दो संख्याओं को एक साथ जोड़ें

• टेस्ट करें कि कोई निश्चित संख्या अभाज्य है या नहीं।

यह एक पुलिस और लुटेरों की चुनौती है, जहां दो अलग-अलग उद्देश्यों के साथ दो अलग-अलग चुनौतियां हैं: पुलिस कुछ कोड लिखने की कोशिश करेगी जो भाषा को अधिकतर अनुपयोगी बनाती है, और लुटेरे छिपे हुए वर्कअराउंड को खोजने की कोशिश करेंगे जो पुलिस को अनुमति देता है उनकी भाषा ठीक करने के लिए।

पुलिस कोड के दो स्निपेट लिखेंगे:

1. एक जो इनपुट / आउटपुट और संख्यात्मक कार्यों को लेने के लिए बनाए गए कार्यों को हटाकर अपनी भाषा को अधिकतर अनुपयोगी बनाता है। इस कोड को क्रैश या बाहर निकलने की अनुमति नहीं है । इस स्निपेट के अंत में कोड जोड़ना संभव होना चाहिए, और उस कोड का मूल्यांकन किया जाएगा । तथा

2. कोड का एक स्निपेट जो इनपुट के रूप में दो नंबर लेता है, उन्हें एक साथ जोड़ता है, और उनका योग आउटपुट करता है। पहला स्निपेट चलाने के बाद भी इस स्निपेट को सही ढंग से काम करना चाहिए। जब दो स्निपेट को एक साथ जोड़ दिया जाता है, तो उन्हें एक पूर्ण प्रोग्राम बनाना चाहिए जो दो नंबर जोड़ता है, या एक फ़ंक्शन को परिभाषित करता है जो दो नंबर जोड़ता है। यह स्निपेट शायद अस्पष्ट व्यवहार पर निर्भर करेगा, और इसे खोजना मुश्किल होगा।

पुलिस इनपुट और आउटपुट के किसी भी मानक तरीके का भी चयन करेगी । हालांकि, उन्हें यह अवश्य बताना चाहिए कि वे किस प्रारूप (इनपुट और आउटपुट) का उपयोग कर रहे हैं। उनके उत्तर को क्रैक करने के लिए, आपको उसी इनपुट / आउटपुट प्रारूप का पालन करना होगा, या आपकी दरार की गिनती नहीं होगी।

एक पुलिस जवाब हमेशा प्रकट होगा

• पहले स्निपेट (स्पष्ट रूप से नहीं सेकंड)।

• भाषा (मामूली संस्करण सहित, क्योंकि अधिकांश प्रस्तुतियाँ शायद अजीब धार वाले मामलों पर भरोसा करेंगी)

• IO प्रारूप, जिसमें यह एक फ़ंक्शन या पूर्ण कार्यक्रम भी शामिल है। मान्य दरार होने के लिए लुटेरों को उसी प्रारूप का उपयोग करना चाहिए ।

• काम करने के लिए उनके जवाब के लिए किसी भी अजीब धार के मामलों की आवश्यकता है उदाहरण के लिए, केवल लिनक्स पर चलता है , या इंटरनेट कनेक्शन की आवश्यकता होती है ।

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

यहाँ एक उदाहरण है। पहले स्निपेट के लिए, आप निम्नलिखित अजगर 3 प्रोग्राम को पुलिस उत्तर के रूप में देख सकते हैं:

अजगर ३

print=None

STDIN से इनपुट लेता है और आउटपुट से STDOUT में जाता है

एक वैध दूसरा स्निपेट हो सकता है

import sys
a,b=int(input()),int(input())
sys.stdout.write(a+b)

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

print=None
import sys
a,b=int(input()),int(input())
sys.stdout.write(a+b)

यह उनके जवाब के लिए एक वैध दरार है।

यदि एक पुलिस का जवाब पूरे एक सप्ताह के लिए अनियंत्रित रहता है, तो वे अपने दूसरे स्निपेट में संपादित कर सकते हैं, और संकेत देते हैं कि उनका जवाब अब सुरक्षित है । सुरक्षित होने के लिए इसे संपादित करने के बाद, आप इसे क्रैक करने का प्रयास नहीं कर सकते। यदि वे इसे सुरक्षित रूप से संपादित नहीं करते हैं, तो आप इसे तब तक क्रैक करने का प्रयास जारी रख सकते हैं जब तक वे ऐसा नहीं करते।

डाकू के धागे की विजेता उपयोगकर्ता के लिए जो टाई ब्रेकर बार वे पहुँच होने के साथ सबसे जवाब फटा है, है एन दरारें। (इसलिए यदि दो अलग-अलग उपयोगकर्ताओं में से प्रत्येक के पास 5 दरारें हैं, उदाहरण के लिए, जो उपयोगकर्ता अपनी 5 वीं दरार पहले पोस्ट करता है वह विजेता है) पर्याप्त समय बीत जाने के बाद, मैं सबसे अधिक वोटों के साथ विजेता के उत्तर को स्वीकार करूंगा।

मज़े करो!

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

• पहला स्निपेट बिना किसी इनपुट के सही ढंग से चलना चाहिए । यह आपको जो भी पसंद हो आउटपुट कर सकता है और इस आउटपुट को नजरअंदाज कर दिया जाएगा। जब तक स्निपेट किया जाता है, तब तक दूसरा स्निपेट सही ढंग से चलता है।

• आपके जवाब के मान्य होने के लिए दूसरे स्निपेट को वास्तव में निष्पादित किया जाना चाहिए । इसका मतलब है जैसे उत्तर

  import sys
  sys.exit()
  

  मान्य नहीं है क्योंकि यह भाषा को नहीं तोड़ता है। यह बस बुझती है।

• सुरक्षित होने के बाद, आपका स्कोर दोनों स्निपेट्स की बाइट गिनती है ।

• यह आपके काम के जवाब के लिए आवश्यक किसी भी अजीब धार के मामलों को प्रकट करने के लिए वापस जाता है ... आपके प्रस्तुत करने से पहले प्रकट होने के बाद प्रतिलिपि प्रस्तुत करने योग्य होने के लिए पर्याप्त जानकारी होनी चाहिए । इसका मतलब है कि यदि आपका उत्तर सुरक्षित हो जाता है, और फिर आप इसमें संपादित करते हैं: यहाँ मेरा उत्तर है। ओह हाँ, BTW यह केवल काम करता है यदि आप इसे Solaris पर चलाते हैं, तो आप पर चुटकुले! आपका उत्तर अमान्य है और हटा दिया जाएगा और जीतने के योग्य नहीं माना जाएगा।

• राशि के उत्पादन के बाद दूसरे स्निपेट को दुर्घटनाग्रस्त होने की अनुमति है। जब तक आउटपुट अभी भी सही है (उदाहरण के लिए, यदि आप STDERR के आउटपुट का चयन करते हैं, और तब आपको क्रैश की जानकारी मिलती है, तो यह अमान्य है)

लीडरबोर्ड

यहां कम से कम एक दरार के साथ हर उपयोगकर्ता की एक सूची है, जो स्कोर द्वारा क्रमबद्ध है और फिर नाम (वर्णमाला)। यदि आप एक दरार जमा करते हैं, तो कृपया अपने स्कोर को तदनुसार अपडेट करें।

#User                       #Score
Ilmari Karonen              8

Dennis                      5

Olivier Grégoire            4

Sisyphus                    3
Veedrac                     3

Arnold Palmer               2
Bruce Forte                 2
DJMcMayhem                  2
Dom Hastings                2
ppperry                     2

1bluston                    1
2012rcampion                1
Ben                         1
BlackCap                    1
Christian Sievers           1
Cody Gray                   1
HyperNeutrino               1
Joshua                      1
Kaz                         1
Mark                        1
Mayube                      1
Xnor                        1
zbw                         1

Answer 1

Olivier Grégoire द्वारा जावा 8

class A {
  public A() {
    String[] args = System.lineSeparator().split(",");
    System.out.print(Integer.parseInt(args[0]) + Integer.parseInt(args[1]));
  }
}

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

चूंकि ओलिवियर ने वीएम तर्कों का उपयोग करके सेट किए गए गुणों के माध्यम से स्पष्ट रूप से पासिंग इनपुट की अनुमति दी है, इसलिए मैं निर्दिष्ट करूंगा कि इनपुट को वीएम तर्क में दिया जाना चाहिए -Dline.separator=X,Y, जहां Xऔर Yनंबर जोड़े जाने हैं। अर्थात्, संख्या 17 और 25 को जोड़ने के लिए, कार्यक्रम को इस प्रकार लागू किया जाना चाहिए:

java -Dline.separator=17,25 Main

मेरा मानना ​​है कि यह कमांड लाइन पर जावा प्रोग्राम चलाने की तुलना में किसी भी सिस्टम पर काम करना चाहिए। यहां तक ​​कि सिस्टम पर जो कमांड लाइन नहीं है, सिस्टम संपत्तियों की स्थापना के लिए किसी भी अन्य समकक्ष तंत्र का उपयोग वीएम को इनपुट पास करने के लिए किया जा सकता है।

---

Ps। यहां मेरा पहले का क्रैकिंग प्रयास है, जिसे JVM- विशिष्ट सुविधाओं का उपयोग करने के कारण अमान्य माना गया था:

class SecurityManager extends sun.awt.AWTSecurityManager {
  static {
    String[] args = System.getProperty("sun.java.command").split(" ");
    int a = Integer.parseInt(args[args.length-2]);
    int b = Integer.parseInt(args[args.length-1]);
    System.out.println(a+b);
  }
}

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

यह पिछले एक की तुलना में बहुत कम क्रिया निकला । कठिन हिस्सा एक उपवर्ग का पता लगा रहा था जो SecurityManager" java." के साथ शुरू होने वाले नामस्थान में नहीं रहता था । मुझे संदेह है कि यह अभी भी इच्छित समाधान नहीं है, लेकिन यह काम करता है। *

^{*) TIO पर, कम से कम; sun.awt.AWTSecurityManagerवर्ग और sun.java.commandसंपत्ति आधिकारिक तौर पर प्रलेखित किया जाना नहीं प्रतीत होती हैं, और सभी JVMs पर उपलब्ध नहीं हो सकता।}

Comments

अच्छी नौकरी! मैंने यह कोशिश की, लेकिन ऐसा नहीं हो सका जो SecurityManagerकि एक गुंजाइश थी ... आप System.inइस बिंदु से भी पढ़ सकते हैं , हालांकि, यह अभी तक बंद नहीं हुआ है।

— zbw

क्षमा करें, यह दो के संबंध में एक प्लेटफ़ॉर्म-निर्भर उत्तर है: दोनों sun.awt.SecurityManagerऔर "sun.awt.command"प्लेटफ़ॉर्म आश्रित हैं और जावा का हिस्सा नहीं हैं ।

— ओलिवियर ग्राएगोयर

हाँ, फटा! :) इरादा समाधान के माध्यम से जाना था System.getProperties().get("blah")(क्योंकि मैंने केवल पहुंच को अवरुद्ध किया है System.getProperty, नहीं System.getProperties), लेकिन यह काफी अच्छा है! बहुत बढ़िया!

— ओलिवियर ग्रेगोइरे

Answer 2

सी (GCC / लिनक्स) Sisyphus द्वारा

यह स्निपेट प्रदान किए गए फ़ंक्शन को बंद कर देता है और एक नया (क्लासिक कोड इंजेक्शन) शुरू करता है, जो खुद को फिर से परिभाषित करता है closeताकि fd को बंद करने के बजाय, हमारा वांछित कोड चला सके।

}
int close(int x) {
  int a, b;
  scanf("%d %d", &a, &b);
  printf("%d\n", a + b);

  exit(0);

Answer 3

अजगर, गेहूं जादूगर के समाधान यहाँ

import sys
c="".join(open(__file__).read().split('\n')[4:])
if set(c)-set(' &)(,.:[]a`cdfijmonrt~')or"import"in c:sys.setrecursionlimit(1)
f=lambda\
:[]                                                      # my code starts here
sys.setrecursionlimit(1000)
print(int(input())+int(input()))

मेरा मतलब है, आप केवल पुनरावृत्ति सीमा निर्धारित कर सकते हैं, और कुछ भी बुरा नहीं होता है ...

TIO पर काम करता है

ध्यान दें

यह मेरा पहला CnR सबमिशन है, इसलिए यदि यह कोई नियम तोड़ता है, तो कृपया मुझे बताएं और मैं इसे हटा दूंगा।

Comments

मैं इसे याद करने के लिए गूंगा हूँ

— गेहूं जादूगर

@WheatWizard :)

— HyperNeutrino

@wheatwizard अभी तक अपने इच्छित समाधान को प्रकट नहीं करता है। मैं चाहता हूँ looove अपने मूल समाधान है कि सुधारों को इस समस्या के साथ एक बेहतर पुलिस को देखने के लिए।

— DJMcMayhem

@Djmcmayhem मैं शायद डेल सीस के साथ प्रजनन करने जा रहा हूं।

— गेहूं जादूगर

@HeatWizard याद रखें os.sys, अगर इससे फर्क पड़ता है: P

— HyperNeutrino

Answer 4

बेन द्वारा हास्केल

import Prelude(getLine,print)
a=a
[]++s=s
(a:as)++s=a:(as++s)
r""=""
r(c:s)=(r s)++[c]
t(_:r)=r
ts l=l:ts(t l)
x[_](v:_)=v
x(_:r)(_:s)=x r s
d(a:_:_:_:_:_:_:_:_:_:r)=a:d r
(a:_)!!""=a
l!!(n:m)=d(x['0'..n](ts l))!!m
a+b=[[0..]!!a..]!!b
a-b=let n=[0..]!!a;m=[0..]!!b in
    case [n..m] of
      [] ->   x[m..n][0..]
      l  -> -(x l    [0..])
add('-':x)('-':y)= -(r x+r y)
add('-':x)y=r y-r x
add x('-':y)=r x-r y
add x y=x+y
main=do a<-getLine;b<-getLine;print(add a b)

मेरे पास अभी भी शाब्दिक संख्याएं और आकर्षण हैं (मैं उपयोग करता हूं 0, '0'और '-'), [a..]और [a..b]जो बहुत उपयोगी हैं। और मेरे पास एकात्मकता है -, लेकिन मैं बिना कर सकता था।

मैं ++लागू करने के लिए r( reverse) को परिभाषित करता हूं और परिभाषित करता हूं tऔर tsजो हैं tailऔर tails। x a bका nतत्व देता है b, जहां ऋण nकी लंबाई aएक है। xआमतौर पर के रूप में परिभाषित किया जा सकता है snd.last.zip। फ़ंक्शन dएक सूची लेता है और उन पदों के तत्वों के साथ एक सूची देता है जो दस के गुणक हैं। l!!sके nवें तत्व को लौटाता है l, जहां sउल्टा स्ट्रिंग प्रतिनिधित्व है n। +उलटे तार के रूप में दिए गए दो प्राकृतिक संख्याओं का योग पूर्णांक के रूप में देता है, इसी तरह -अंतर के लिए। addदो पूर्णांक के रूप में रिटर्न संभवत: नकारात्मक पूर्णांक तार के रूप में दिया जाता है।

मुझे आश्चर्य है कि अगर यह कुछ हद तक बेन के दिमाग में था।

Comments

हां, बहुत ही समान विचार। समानता परीक्षण और ब्रांचिंग प्राप्त करने के लिए शाब्दिक के खिलाफ पैटर्न मिलान, वेतन वृद्धि का एक रूप पाने के लिए गणना सिंटैक्स की सूची बनाएं। मुझे यह जानकर काफी आश्चर्य हुआ :कि NoImplicitPreludeकुछ भी आयात किए बिना भी इसके दायरे में था ।

— बेन

Answer 5

कॉनर ओ'ब्रायन द्वारा सी (gcc)

void post_main() __attribute__ ((destructor));

void post_main()
{
    int a, b;
    char sum[11];
    void *stdin = fdopen(0, "r");

    fscanf(stdin, "%u %u", &a, &b);
    sprintf(sum, "%u", a + b);
    write(1, sum, strlen(sum));
}

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

Comments

ugggg मैं fscanf और उन अन्य कार्यों के बहुत सारे प्रतिबंधों को भूल गया>> अच्छा काम

— Conor O'Brien

Answer 6

गेहूं जादूगर द्वारा अजगर 2 (चौथा पुनरावृत्ति)

import sys
if set("".join(open(__file__).read().split('\n')[4:]))-set(' &)(,.:[]a`cdfijmonrt~'):sys.setrecursionlimit(1)
for m in sys.modules:sys.modules[m]=None
del sys;f=lambda\
c,d:(`int([]in[])`[:[]in[]]).join([((c)and`dict([((int([]in[])),(int([]in[])))])`[(int([]in[[]])):][(int([]in[[]]))].join([`dict([((int([]in[])),(int([]in[])))])`[(int([]in[]))],`dict([((int([]in[])),c)])`[(int([]in[[]])):][(int([]in[[]])):][(int([]in[[]])):][(int([]in[[]])):]])or`int([]in[])`[:[]in[]]).format((int([]in[]))),((d)and`dict([((int([]in[])),(int([]in[])))])`[(int([]in[[]])):][(int([]in[[]]))].join([`dict([((int([]in[])),(int([]in[])))])`[(int([]in[]))],`dict([((int([]in[])),d)])`[(int([]in[[]])):][(int([]in[[]])):][(int([]in[[]])):][(int([]in[[]])):]])or`int([]in[])`[:[]in[]]).format((int([]in[]))),`(int([]in[]))`]).rfind(`(int([]in[]))`)

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

कोई कारनामे नहीं, केवल ' &)(,.:[]a`cdfijmonrt~'इच्छित (वास्तव में केवल '(),.:[]`acdfijmnort') का उपयोग करके केवल वर्ण जोड़ने के लिए एक फ़ंक्शन ।

मैंने इसे छोटा करने का कोई प्रयास नहीं किया; मैंने सिर्फ इंटरमीडिएट मानों जैसे 0 और खाली स्ट्रिंग और स्ट्रिंग-सब-इंट्रस्टेड लोगों के लिए सबटेक्शन्स लिखे।

def f(c,d):
	FALSE = []in[]
	TRUE = []in[[]]
	ZERO = int([]in[])
	ONE = int(TRUE)
	EMPTY = `int([]in[])`[:[]in[]]
	ZERO_STR = `ZERO`
	ONE_STR = `ONE`

	ZERO_DICT = dict([(ZERO,ZERO)])
	ZERO_DICT_STR = `ZERO_DICT`

	OPEN_BRACE = ZERO_DICT_STR[ZERO]
	COLON = ZERO_DICT_STR[ONE:][ONE]
	CLOSE_BRACE = ZERO_DICT_STR[ONE:][ONE:][ONE:][ONE:][ONE]

	C_STR = `c`
	D_STR = `d`

	FORMAT_STR_C = ''.join([OPEN_BRACE, ZERO_STR, COLON, C_STR, CLOSE_BRACE])
	FORMAT_STR_D = ''.join([OPEN_BRACE, ZERO_STR, COLON, D_STR, CLOSE_BRACE])

	LENGTH_C_STR = c and FORMAT_STR_C.format(ONE_STR) or EMPTY
	LENGTH_D_STR = d and FORMAT_STR_D.format(ONE_STR) or EMPTY

	TOTAL_STR = EMPTY.join([LENGTH_C_STR, LENGTH_D_STR, ZERO_STR])
	RESULT = TOTAL_STR.find(ZERO_STR)

	return RESULT

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

मुख्य विचार यह है कि स्ट्रिंग प्रारूप '{0:5}'.format('1')संख्या शून्य को लंबाई की 5तरह पैड करता है '1 '। संघनन दो ऐसे तारों का उपयोग करके ''.join, उनकी लंबाई का योग इनपुट संख्याओं का योग है। फिर, हम अंतिम 0छोर पर आते हैं और .find()अंतिम स्थिति पर कॉल करते हैं, जो कि राशि है।

स्ट्रिंग '{0:5}'टू फॉर्मेट का निर्माण {:}डिक्शनरी के स्ट्रिंग रिप्रजेंट से पात्रों को निकालने के साथ किया जाता है dict। प्रत्येक क्रमिक सारांश के स्ट्रिंग रीप को रखा जाता है जहां 5 होगा। मैं {0:5}खुद की तरह एक तानाशाही का उपयोग करना चाहता था , लेकिन इसकी पुनरावृत्ति में एक स्थान शामिल है जिसने इसे गड़बड़ कर दिया।

0 के इनपुट प्रक्रिया में गड़बड़ी करते हैं क्योंकि स्ट्रिंग उप की न्यूनतम लंबाई 1. है। हमारे पास and/orइस मामले में खाली स्ट्रिंग देने के लिए है।

Comments

यह मेरे इरादे से काफी अलग है, मैं एक स्पष्टीकरण देखना पसंद करूंगा।

— गेहूं जादूगर

आप अपने सभी int([]in[])को बस के int()रूप में गोल्फ कर सकते हैं दोनों का उत्पादन होगा 0.

— वैल्यू इंक

Answer 7

हास्केल, लाइकोनी द्वारा

main=main--
 & ((+) <$> readLn <*> readLn >>= print)
i&o=o

Answer 8

जोशुआ द्वारा x86 16-बिट रियल-मोड असेंबली

    int  0x3                  ; <---  this is the "robber" portion

    ; -- begin code to print numbers in real-mode asm using ROM BIOS video interrupts --
    add  dx, cx               ; add input values together
    mov  ax, dx               ; move result into AX
    push WORD 0xB800
    pop  ds                   ; DS == starting address of text-mode video buffer
    xor  cx, cx               ; digit counter
    xor  di, di               ; position counter
    mov  bx, 0xA              ; divisor

    test ax, ax               ; is number negative?
    jns  .GetDigits
    neg  ax                   ; convert negative number to positive
    mov  WORD ds:[di], 0x4F2D ; output leading negative sign, in white-on-red
    add  di, 2                ; increment position counter

.GetDigits:
    xor  dx, dx
    div  bx                   ; divide DX:AX by 10 (AX == quotient, DX == remainder)
    push dx                   ; push digit onto stack
    inc  cx                   ; increment digit counter
    test ax, ax
    jnz  .GetDigits           ; keep looping until we've got 'em all

.PrintDigits:
    pop  dx                   ; get digit off of stack
    dec  cx                   ; decrement digit counter
    mov  dh, 0x4F             ; high byte: color attribute (white-on-red)
    add  dl, 0x30             ; low  byte: convert to ASCII
    mov  WORD ds:[di], dx     ; output digit
    add  di, 2                ; increment position counter
    test cx, cx
    jnz  .PrintDigits         ; keep looping until we've printed 'em all

    cli
    hlt

स्पष्टीकरण:

जोशुआ के कोड द्वारा पेश किया गया "टूटना" ट्रैप फ्लैग (TF) की सेटिंग है, जो CPU को सिंगल-स्टेप मोड में रखता है। इसका मतलब है कि एक बार में केवल एक ही निर्देश निष्पादित किया जाएगा, इससे पहले कि सीपीयू बंद हो जाता है (टाइप्स) एक टाइप -1 रुकावट के साथ। यह वह है जो डिबगर्स को कोड के एकल-चरण को लागू करने की अनुमति देता है - वहां काफी आसान है, लेकिन यदि आप डिबगर के संदर्भ के बाहर कोड चलाना चाहते हैं तो एक वास्तविक पीआईटीए!

यह कोड का निम्नलिखित भाग है जो ट्रैप फ़्लैग पर मुड़ता है:

pushf               ; push the FLAGS register onto the top of the stack
mov bp, sp          ; load the pointer to the top of the stack into BP
or word [bp], 256   ; bitwise-OR the WORD at the top of the stack (the copy of FLAGS)
                    ;  with 0x100, which turns on bit 8 (TF)
popf                ; pop the modified flags back off the stack into FLAGS

ट्रैप फ़्लैग के कार्यान्वयन का अर्थ है कि हमें सीपीयू ट्रैप्स से ठीक पहले एक निर्देश निष्पादित करने का मौका मिलता है - वह वह है जो POPFयहाँ के तुरंत बाद आता है। इसलिए, हमें यह एक गणना करने की आवश्यकता है।

चाल INT 3निर्देश है, जो बाधा संख्या 3 को आमंत्रित करता है। दो कारण हैं कि यह कोड को "अनब्रेक" करने के लिए क्यों काम करता है:

1. बाधा हैंडलर में जाल का झंडा साफ किया जाता है। यह इंटेल के डिजाइन का सिर्फ एक हिस्सा है, लेकिन यह मूल रूप से पवित्रता कारणों से किया गया था। याद रखें कि ट्रैप फ़्लैग का कार्यान्वयन यह है कि प्रत्येक निर्देश के निष्पादन के बाद टाइप -1 इंटरफ़ेक्ट को लागू किया जाता है, इसलिए यदि टीएफ को मंजूरी नहीं दी गई थी, तो INT 1वह स्वयं एक बाधा को ट्रिगर करेगा - यह सभी तरह से बाधित हो जाएगा। इसके अलावा, स्पष्ट टीएफ में व्यवधान होने से सिर्फ कोड को डीबग करना आसान हो जाता है, यह एक आईडीई की तरह होता है जो स्वचालित रूप से पुस्तकालय कार्यों के लिए कॉल पर कदम रखता है।

2. जिस तरह से काम में रुकावट आती है वह मूल रूप से एक समान है CALL। वे उस बाधा हैंडलर का आह्वान करते हैं जिसका पता वैश्विक रुकावट वेक्टर तालिका में इसी स्थिति में संग्रहीत है। चूंकि यह तालिका पते पर शुरू होती है 0x0000:0000, और इसे 4-बाइट segment:offsetप्रारूप में संग्रहीत किया जाता है , पते की गणना करना रुकावट वेक्टर / संख्या द्वारा 4 को गुणा करने जितना सरल है। इस मामले में, हम 3 को रोकते हैं, इसलिए यह 4 × 3 = 12 होगा।

   ... और आप देखेंगे कि यहोशू ने सोच-समझकर हमारे लिए इसे स्थापित किया था। जाल ध्वज को सक्षम करने से पहले, उसके पास निम्नलिखित कोड हैं:

   mov  di, 12
   mov  [di], si
   mov  [di + 2], bp
   

   जो 0x0000:000C(के लिए बाधा हैंडलर INT 3) सेट करता है BP:SI। इसका मतलब यह है कि जब भी INT 3आह्वान किया जाता है, तो यह स्टैग पर एफएजीएस रजिस्टर को धकेलता है, इसके बाद रिटर्न एड्रेस और फिर ब्रांच्स BP:SI, जो हमें कोड को फिर से निष्पादित करना शुरू कर देता है, एक संदर्भ में जहां ट्रैप फ्लैग बंद हो जाता है।

यह सब के बाद डाउनहिल है INT 3। हमें केवल दो संख्याओं को एक साथ जोड़ना होगा और परिणाम प्रिंट करना होगा। सिवाय इसके कि यह असेंबली भाषा में उतना सरल नहीं है जितना कि अन्य भाषाओं में होगा, इसलिए यह वह जगह है जहां कोड का थोक खर्च किया जाता है।

जोशुआ डाकू को किसी भी I / O तंत्र को निर्दिष्ट करने की अनुमति दे रहा है , जो वह चाहता है , इसलिए मैं यह मानने का सरलीकृत दृष्टिकोण ले रहा हूं कि मान DXऔर CXरजिस्टर में पारित हो गए हैं । यह उचित है, क्योंकि ये उनके "प्रस्तावना" कोड द्वारा कहीं भी बंद नहीं हैं।

फिर आउटपुट ASCII बाइट्स को सीधे वीडियो मेमोरी में स्टोर करके किया जाता है। वीडियो बफर 0xB800:0000एक टेक्स्ट-मोड CGA, EGA, और / या VGA पर शुरू होता है , इसलिए हम वहां प्रिंट करना शुरू करते हैं। प्रारूप है: निम्न बाइट में वर्ण, और उच्च बाइट में रंग विशेषता। इसका मतलब है कि प्रत्येक चरित्र 2-बाइट ऑफसेट पर है। हम बस संख्या (आधार -10) में प्रत्येक अंक के माध्यम से पुनरावृति करते हैं, उन्हें ASCII में परिवर्तित करते हैं और स्क्रीन पर एक बार उन्हें मुद्रित करते हैं। हां, यह बहुत कोड है। विधानसभा भाषा में हमारी मदद करने के लिए कोई पुस्तकालय कार्य नहीं हैं। यह लगभग निश्चित रूप से आगे अनुकूलित किया जा सकता है, लेकिन मैं इस पर काम करने से थक गया ...

आउटपुट प्रदर्शित होने के बाद, कोड को क्रैश करने या जो कुछ भी करने की अनुमति दी जाती है, इसलिए हम बस सीपीयू को बाधित और रोकते हैं।

Comments

मैं चकरा गया हूं; मैं यह पता नहीं लगा सकता कि यह बीपी पर सबसे पहले निर्देश कैसे प्राप्त करता है: एसपी + 1।

— जोशुआ

@ जोशुआ हम्म, यह एक अच्छी बात है। मैंने उसके बारे में सोचा भी नहीं था। डिबग में कोड के माध्यम से कदम रखते हुए, मैं INT 3इसका पालन करने के निर्देश पर तुरंत वापस निष्पादित करता हूं और समाप्त करता हूं, इसलिए मैं इसके साथ चला गया। शायद मेरे परीक्षण वातावरण के साथ कुछ करना है? CLIकेवल हार्डवेयर व्यवधान को अक्षम करेगा, लेकिन यदि यह अतीत में मिला है HLT, तो आपको लगता है कि यह इसके माध्यम से गिर जाएगा और lइसके तुरंत बाद कोड निष्पादित करेगा ।

— कोडी ग्रे

ओह, आप सिंगल स्टेपिंग कर रहे थे। हाँ, यह करना होगा। मैं दोहरी जांच करने जा रहा हूं लेकिन मुझे लगता है कि मैंने अजीब कोड अपलोड किया है।

— जोशुआ

मैंने सिंगल-स्टेपिंग के बिना भी परीक्षण किया। कोई फर्क नहीं। यह वीएम वर्चुअलबॉक्स में नवीनतम फ्रीडोस पर है। मेरे पास असली हार्डवेयर उपलब्ध है, लेकिन इसे पॉवर देने का मन नहीं था। @ जोशुआ

— कोड़ी ग्रे

अच्छी तरह से आप स्पष्ट रूप से तो यह टूट गया। हो सकता है कि आपको उस एनएमआई को बढ़ाने का एक तरीका मिल गया हो।

— जोशुआ

Answer 9

ट्विननाइट द्वारा पायथन 2

print input()+input() #

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

Comments

Dammit! इस बारे में भूल गए। फिर एक नए उत्तर के लिए समय।

— ट्विनट

Answer 10

पायथन 3 , पपीरी का दूसरा चैलेंज

वाह, यह मजेदार था! मुझे इसे हल करने में मज़ा आया।

संपादित करें: ठीक है, मैंने इसे ठीक किया। ऐसा लगता है जैसे मेरे कंप्यूटर पर टीआईओ की उपवर्ग सूची में कक्षाएं एक अलग सूचकांक में थीं, इसलिए मैंने इसे दोनों के लिए काम किया, और एक टीआईओ जोड़ा।

import sys
for mod in sys.modules.values():mod.__dict__.clear()
1+1

# My code begins here
str = "Hello!".__class__
int = (37).__class__
object = str.__base__

def find_subclass(superclass, name):
	for cls in superclass.__subclasses__():
		if cls.__name__ == name:
			return cls

_io_IOBase      = find_subclass(object, '_IOBase')        # <class '_io._IOBase'>
_io_RawIOBase   = find_subclass(_io_IOBase, '_RawIOBase') # <class '_io._RawIOBase'>
_ioFileIO       = find_subclass(_io_RawIOBase, 'FileIO')  # <class '_io.FileIO'>
stdout = _ioFileIO('stdout', mode='w', opener=lambda name,flags: 1) # FD for stdout is 1
stdin  = _ioFileIO('stdin',  mode='r', opener=lambda name,flags: 0) # FD for stdin is 0
nums = str(stdin.read(), encoding='utf-8').split()
stdout.write(str(int(nums[0]) + int(nums[1])).encode('utf-8') + b'\n')
stdout.flush()

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

Comments

मुझे एक त्रुटि मिलती है। sys.excepthook is missing?

— R

हम्म ... मेरे लिए काम करता है। वास्तविक त्रुटि आपको क्या हो रही है? (ऐसा इसलिए हो रहा है क्योंकि पपीरी के कोड ने बहुत कुछ नष्ट कर दिया है, जिसमें अपवादों को दिखाना भी शामिल है, इसलिए ऐसा है sys.excepthook, लेकिन वहाँ कहीं एक वास्तविक कारण सूचीबद्ध होगा।)

— zbw

कोई बात नहीं, असली त्रुटि है IndexError('list index out of range',)। यह की परिभाषा के साथ लाइन पर है _io_RawIOBase।

— R

समस्या यह है कि उपवर्गों का क्रम तय नहीं है। _io_IOBase = [cls for cls in object.__subclasses__() if cls.__name__ == '_IOBase'][0]हर जगह काम करना चाहिए।

— डेनिस

@ डेनिस येप, मुझे एहसास हुआ कि और बस इसे ठीक कर दिया। यह अब TIO पर काम करता है!

— zbw

Answer 11

Zbw द्वारा हास्केल

{-#OPTIONS_GHC -fth -w#-}
module M where

import Language.Haskell.TH.Syntax
import System.IO.Unsafe

a = $( runIO $ TupE[] <$
              do x <- readLn :: IO Integer
                 y <- readLn
                 print $ x + y )

रन-टाइम पर कोड नहीं चलाया जा सकता? संकलन के समय इसे चलाएं!

यह बहुत मजेदार था, मुझे इस चुनौती से पहले टेम्प्लेट हैस्केल का पता नहीं था।

Answer 12

हाइपर न्यूट्रिनो द्वारा जेली

+

सुपर सिंपल है। न्यूलाइन पहली कड़ी का कारण बनता है जिसे न कहा जाए।

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

Comments

आप इस

— जोनाथन एलन

हाँ, मुझे लगा कि यह बहुत आसान होगा।

— हाइपरनेत्रिनो

Answer 13

गेहूं जादूगर द्वारा अजगर 2

import sys
c="".join(open(__file__).read().split('\n')[4:])
if set(c)-set(' &)(,.:[]a`cdfijmonrt~')or"import"in c:sys.setrecursionlimit(1)
sys.modules['sys'],sys.modules['os']=None,None;del sys;f=lambda\
a,b:a+b
__import__('sysconfig').__dict__['os'].__dict__['sys'].setrecursionlimit(1000)
print(f(1,2))

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

Comments

यह मेरे विचार से अधिक कठिन है।

— गेहूं जादूगर

Answer 14

जावा लॉर्डफार्कड द्वारा

स्रोत स्तर पर वस्तुओं तक पहुंच को रोकना वास्तव में स्मार्ट था (और परीक्षण करते समय कष्टप्रद), अच्छी तरह से किया!

public class java {
  public static void main(String[] s) {
    //there is no executable code in snippet one.
    //your code here.
    try {
      ClassLoader cl = ClassLoader.getSystemClassLoader();
      Object in = cl.loadClass("java.lang.System").getDeclaredField("in").get(null);
      Object out = cl.loadClass("java.lang.System").getDeclaredField("out").get(null);
      Object scanner = cl.loadClass("java.util.Scanner").getConstructor(cl.loadClass("java.io.InputStream")).newInstance(in);
      int i = (Integer)cl.loadClass("java.util.Scanner").getMethod("nextInt").invoke(scanner);
      int j = (Integer)cl.loadClass("java.util.Scanner").getMethod("nextInt").invoke(scanner);
      cl.loadClass("java.io.PrintStream").getMethod("println", Object.class).invoke(out, i+j);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  class Class {}
  class Method {}
  class System {}
  class FileDescriptor {}
  class Logger {}
  class Runtime {}
  class Scanner {}
}

Comments

अच्छा! क्या हुआ अगर ClassLoaderछाया हुआ था?

— जकॉब

@ जाकोबॉर्नेल "".getClass().getClassLoader()। शैडोइंग आमतौर पर केवल एक समस्या है जिसके बारे में आपको एक बार सोचना है और फिर यह ठीक है। तुम भी छाया सकता है Object, मैं अभी भी इसे हल करने में सक्षम हो जाएगा। ठीक है, आप मुझे 1kb समाधान में मजबूर कर सकते हैं, लेकिन यह संभव है।

— ओलिवियर ग्रेगोइरे

Answer 15

हिस्टोक्रेट द्वारा रूबी

BEGIN{exit(gets.to_i + gets.to_i)}

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

Answer 16

सूचित 7, इल्मरी करोनन द्वारा

अस्पष्ट संज्ञाओं का घोर दुरुपयोग ... मेरा कोड इसके साथ शुरू होता है factory is a room। पिछली पंक्ति पुलिस का कोड है। add 1 and 1उदाहरण के लिए, 2 पाने के लिए टाइप करें।

For reading a command: Rule fails

factory is a room.
The adder one is a thing. The adder two is a thing. The adder one is in factory. The adder two is in factory.
Before reading a command: change the text of the player's command to "examine adder"

For printing a parser error: 
    if the player's command includes "add [number] ":
        let N be the number understood;
        if the player's command includes "and [number]":
            say the number understood plus N;

Answer 17

जावा, रोमन ग्रैफ़

public class Main {
    public static void main(String... args){
        System.setOut(null);
        System.setErr(null);

        System.setOut(new java.io.PrintStream(new java.io.FileOutputStream(java.io.FileDescriptor.out)));
        System.setErr(new java.io.PrintStream(new java.io.FileOutputStream(java.io.FileDescriptor.err)));
        System.out.println("This");
        System.err.println("works");
    }
}

सेट stdoutऔर stderrवापस अपने प्रारंभिक मूल्यों के लिए।

मेरा मानना ​​है कि मैं आयात के बजाय पूरी तरह से योग्य नाम का उपयोग करने में सक्षम हूं, अगर मैं गलत हूं तो कृपया मुझे सही करें (यह मेरी यहां पहली पोस्ट है।) यह शायद प्रतिबिंब के रूप में भी उपयोग किया जा सकता है।

संपादित करें: यहां केवल एक चिंतनशील समाधान का उपयोग किया जा रहा है java.lang.reflect.*:

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Test {
    public static void main(String... args) {
        System.setOut(null);
        System.setErr(null);

        try {
            Class<?> psClass = Class.forName("java.io.PrintStream");
            Class<?> fsClass = Class.forName("java.io.FileOutputStream");
            Class<?> osClass = Class.forName("java.io.OutputStream");
            Class<?> fdClass = Class.forName("java.io.FileDescriptor");
            Class<System> sClass = System.class;
            Constructor psCtor = psClass.getConstructor(osClass);
            Constructor fsCtor = fsClass.getConstructor(fdClass);

            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);

            Object sout = psCtor.newInstance(fsCtor.newInstance(fdClass.getDeclaredField("out").get(null)));
            Field outField = sClass.getDeclaredField("out");
            modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL);
            outField.set(null, sout);

            Object serr = psCtor.newInstance(fsCtor.newInstance(fdClass.getDeclaredField("err").get(null)));
            Field errField = sClass.getDeclaredField("err");
            modifiersField.setInt(errField, outField.getModifiers() & ~Modifier.FINAL);
            errField.set(null, serr);

            System.out.println("This");
            System.err.println("works");
        } catch (Exception ignore) {
        }
    }
}

Comments

हां, stdin, stdoutऔर stderrकहीं और जमा हो जाती है! आपको उपयोग करने की भी आवश्यकता नहीं है setOutऔर setErrजैसा कि आप PrintStreamसीधे उपयोग कर सकते हैं।

— ओलिवियर ग्रैगोइरे

जोड़ा चिंतनशील समाधान के साथ ही मुझे लगता है कि यह वही था जो शुरू में उम्मीद की गई थी

— मोइरा

Answer 18

डैनियल फ्रैंकलिन द्वारा जावास्क्रिप्ट

location="data:text/html;base64,PHNjcmlwdD5jb25zb2xlLmxvZygxKnByb21wdCgpKzEqcHJvbXB0KCkpPC9zY3JpcHQ+"

इसे थोड़ा धोखा देने वाला समाधान माना जा सकता है, लेकिन यह मेरे लिए क्रोमियम 59 / लिनक्स पर काम करता है, भले ही मुझे कोई चेतावनी प्राप्त न हो:

आगामी संस्करण सामग्री-आरंभ किए गए शीर्ष फ़्रेम नेवीगेशन को डेटा: URL पर ब्लॉक कर देंगे। अधिक जानकारी के लिए, https://goo.gl/BaZAea देखें ।

Ps। यहाँ एक और दरार है, इस बार चेतावनी के बिना:

Node.prototype.removeChild=function(){}
document.body.innerHTML='<iframe src="data:text/html;base64,PHNjcmlwdD5jb25zb2xlLmxvZygxKnByb21wdCgpKzEqcHJvbXB0KCkpPC9zY3JpcHQ+"/>'

Comments

मुझे लगता prompt()- -prompt()है कि

— मैरी

Answer 19

Olivier Grégoire द्वारा जावा 8

एक बेहद क्रिया चुनौती के लिए एक कठोर क्रिया दरार। :) अप्रत्यक्ष रूप से उन वर्गों के साथ काम करने का दर्द, जिन्हें आप नाम नहीं दे सकते।

    try {
      Class loader = Class.class.getMethod("getClassLoader").getReturnType();
      Object sysLoader = loader.getMethod("getSystemClassLoader").invoke(null);
      Class integer = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.lang.Integer");
      Class system  = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.lang.System");
      Class filein  = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.io.FileInputStream");

      InputStream cmd = (InputStream) filein.getConstructor(String.class).newInstance("/proc/self/cmdline");
      byte[] buf = new byte[65536];
      int len = cmd.read(buf);
      String[] args = new String(buf, 0, len).split("\0");
      
      int a = (int) integer.getMethod("parseInt", String.class).invoke(null, args[args.length-2]);
      int b = (int) integer.getMethod("parseInt", String.class).invoke(null, args[args.length-1]);

      Object out = system.getField("out").get(null);
      out.getClass().getMethod("println", String.class).invoke(out, ""+(a+b));
    } catch (Exception e) {
      throw new Error(e);
    }
  }
}
class ClassLoader {
  public static ClassLoader getSystemClassLoader() { return new ClassLoader(); }
  public ClassLoader loadClass(String s) { return this; }
  public ClassLoader getDeclaredField(String s) { return this; }
  public ClassLoader getMethod(String s) { return this; }
  public ClassLoader getMethod(String s, Class c) { return this; }
  public InputStream get (Object o) { return new FakeInputStream(); }
  public void invoke(Object o, SecurityManager sm) {}
}
class FakeInputStream extends InputStream {
  public int read() {
    return -1;

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

Ps। यहां मेरा पहला प्रयास है, ओलिवियर द्वारा लिखित से पहले स्पष्ट किया गया था कि इनपुट को कमांड लाइन तर्क के माध्यम से लिया जाना था। ऊपर की दरार के विपरीत, यह लिनक्स-विशिष्ट नहीं है।

    try {
      Class loader = Class.class.getMethod("getClassLoader").getReturnType();
      Object sysLoader = loader.getMethod("getSystemClassLoader").invoke(null);
      Class integer = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.lang.Integer");
      Class system  = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.lang.System");
      Class scanner = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.util.Scanner");

      InputStream in = (InputStream) system.getField("in").get(null);
      Object scanIn = scanner.getConstructor(InputStream.class).newInstance(in);

      int a = (int) scanner.getMethod("nextInt").invoke(scanIn);
      int b = (int) scanner.getMethod("nextInt").invoke(scanIn);

      Object out = system.getField("out").get(null);
      out.getClass().getMethod("println", String.class).invoke(out, ""+(a+b));
    } catch (Exception e) {
      throw new Error(e);
    }
  }
}
class ClassLoader {
  public static ClassLoader getSystemClassLoader() { return new ClassLoader(); }
  public ClassLoader loadClass(String s) { return this; }
  public ClassLoader getDeclaredField(String s) { return this; }
  public ClassLoader getMethod(String s) { return this; }
  public ClassLoader getMethod(String s, Class c) { return this; }
  public InputStream get (Object o) { return new FakeInputStream(); }
  public void invoke(Object o, SecurityManager sm) {}
}
class FakeInputStream extends InputStream {
  public int read() {
    return -1;

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

Comments

यदि आप इसके लिए तैयार हैं, तो यहां मेरी नई चुनौती है ।

— ओलिवियर ग्रेगोइरे

बस इसे यहां लिखने के लिए: क्योंकि मुझे "गोचचा! यह केवल एक प्रणाली पर काम करने का अधिकार नहीं है", यह जवाब पूरी तरह से चुनौती नहीं देता है क्योंकि यह केवल लिनक्स पर काम करता है।

— ओलिवियर ग्रेगोइरे

@ ओलिवियरग्राउयर: एफडब्ल्यूआईडब्ल्यू, मैं एक वैकल्पिक समाधान के साथ आया था जिसका उपयोग String[] args = ((String) system.getMethod("getProperty", String.class).invoke(null, "sun.java.command")).split(" ");लिनक्स-विशिष्ट नहीं है, लेकिन कुछ जेवीएम द्वारा निर्धारित एक अनिर्दिष्ट संपत्ति प्रतीत होती है।

— इल्मरी करोनन

वह अभी भी पोर्टेबल नहीं है। उदाहरण के लिए, यह आईबीएम जावा पर काम नहीं करेगा। हालाँकि, यह एक अच्छा विचार है! :)

— ओलिवियर ग्रेगोइरे

Answer 20

C # (.NET Core) raznagul द्वारा

मुझे लगता है कि यह इच्छित समाधान नहीं था।

int a;
int b;

using (var f = new System.IO.FileStream("/dev/stdin", System.IO.FileMode.Open, System.IO.FileAccess.Read))
{
using (var fs = new System.IO.StreamReader(f))
{
a = int.Parse(fs.ReadLine());
b = int.Parse(fs.ReadLine());
}
}
using (var f = new System.IO.FileStream("/dev/stdout", System.IO.FileMode.Open, System.IO.FileAccess.Write))
{
using (var fs = new System.IO.StreamWriter(f))
{
fs.WriteLine((a + b).ToString());
}
}

Comments

/dev/std*वहाँ के साथ अच्छा चाल । मैंने शुरू में एक समान दृष्टिकोण के लिए लक्ष्य किया था, लेकिन सिस्टम के लिए एक्सेस के बिना स्टैडेन / आउट के लिए स्ट्रीम खोलने का कोई आसान तरीका नहीं मिल सका, इसलिए मैंने इसके बजाय प्रतिबिंब का विकल्प चुना। बेशक, आपका समाधान संभवतः केवल उचित /devप्रविष्टियों के साथ लिनक्स और अन्य यूनिक्स प्रणालियों पर काम करता है , लेकिन raznagul ने स्पष्ट रूप से यह नहीं कहा कि इसे विंडोज पर काम करना था । और यह TIO पर काम करता है।

— इल्मरी करोनन

@ इल्मारीकरोन: वास्तव में; और अगर यह Windows TIO पर विफल होता, तो मेरी योजना।

— जोशुआ

Answer 21

Java, racer290 द्वारा

यह बल्कि एक बुनियादी अनदेखी थी कि staticशुरुआती को mainविधि से पहले बुलाया जाता है । यह एक अच्छी कोशिश थी: मैं पहले तो निराश हो गया throw new Error(), लेकिन अंत में रास्ता मिल गया;)

public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException, NoSuchMethodException {

    try {

        System.class.getField("in").set(null, null);
        System.class.getField("out").set(null, null);
        System.class.getField("err").set(null, null);

        System.class.getMethod("getSecurityManager", new Class[0]).setAccessible(false);

        File.class.getField("fs").set(null, null);

        for (Method m : Class.class.getMethods()) {

            m.setAccessible(false);

        }

        SecurityManager mngr = new SecurityManager() {

            @Override
            public void checkPermission(Permission p) {

                throw new Error("Muahaha!");

            }

            @Override
            public void checkLink(String s) {

                throw new Error("Not this way, my friend!");

            }

        };

        System.setSecurityManager(mngr);

    } catch (Throwable t) {

    }
    // My code here, I guess...
} static {
  java.util.Scanner s = new java.util.Scanner(System.in);
  System.out.println(s.nextInt()+s.nextInt());

    // End of my code
}

Comments

System.out.println("Hello World!");दो पूर्णांक नहीं जोड़ता है? .. " 2. कोड का एक स्निपेट जो इनपुट के रूप में दो नंबर लेता है, उन्हें एक साथ जोड़ता है, और उनकी राशि को आउटपुट करता है। यह स्निपेट पहले स्निपेट को चलाने के बाद भी सही ढंग से कार्य करना चाहिए। जब ​​दो स्निपेट होते हैं। संयुक्त रूप से, उन्हें एक पूर्ण कार्यक्रम बनाना चाहिए जो दो नंबर जोड़ता है, या एक फ़ंक्शन को परिभाषित करता है जो दो नंबर जोड़ता है। यह स्निपेट संभवतः अस्पष्ट व्यवहार पर निर्भर करेगा, और खोजने में कठिन होगा। "

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

@ केविनक्रूजसेन मैं क्या कह सकता हूं? यदि पुलिस अपना काम नहीं करती है, तो मुझे उनका क्यों करना चाहिए? : पी

— ओलिवियर ग्रैगोइरे

@ केविनक्रूजसेन वहाँ, मैंने वहाँ एक अतिरिक्त लगाया।

— ओलिवियर ग्रेगोइरे

@ OlivierGrégoire पूरे बिंदु को संख्याओं को जोड़ने से रोकना है, चाहे इनपुट की क्षमता को हटाकर, जोड़ना या आउटपुट करना हो।

— स्टीफन

@ स्टेफ़ेन हां, मैंने इसे थोड़ा और बाद में समझा। यह देखने के लिए मेरी 3 अन्य दरारें देखें कि मैं आखिरकार समझ गया था;)

— ओलिवियर ग्रेजायर

Answer 22

केविन क्रूज़सेन द्वारा जावा

अच्छी तरह से निर्माण किया हुआ। इस चुनौती को हल करने के लिए किसी को ठीक से विचार करने के लिए बहुत सारे कोड। मुझे लगता है कि "बाद में अपना कोड डालें" एक बड़ा, बड़ा संकेत था।

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileDescriptor;
import java.io.FilePermission;
import java.io.PrintStream;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Main {

  // Put everything in a static block so it is run before the static main method 
  // and any trailing (static) initializer-blocks:
  static {
    try {
      initializing();
    } catch (final Exception e) {
    }
  }

  static void initializing() throws Exception {
    // Overwrite System.out, System.err and System.in:
    System.setOut(new PrintStream(new ByteArrayOutputStream()));
    System.setErr(new PrintStream(new ByteArrayOutputStream()));
    System.setIn(new ByteArrayInputStream(new byte[0]));

    // Enable reflection for System.out, System.err and System.in:
    final Field modifiersField = Field.class.getDeclaredField("modifiers");
    modifiersField.setAccessible(true);
    final Class<?> fdClass = java.io.FileDescriptor.class;
    final Field outField = fdClass.getDeclaredField("out");
    outField.setAccessible(true);
    modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL);
    final Field errField = fdClass.getDeclaredField("err");
    errField.setAccessible(true);
    modifiersField.setInt(errField, errField.getModifiers() & ~Modifier.FINAL);
    final Field inField = fdClass.getDeclaredField("in");
    inField.setAccessible(true);
    modifiersField.setInt(inField, inField.getModifiers() & ~Modifier.FINAL);

    // Replace existing System.out FileDescriptor with a new (useless) one:
    outField.set(null, new FileDescriptor());
    // Replace existing System.err FileDescriptor with a new (useless) one:
    errField.set(null, new FileDescriptor());
    // Replace existing System.in FileDescriptor with a new (useless) one:
    inField.set(null, new FileDescriptor());

    // Disable reflection for System.out, System.err, System.in again:
    modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL);
    modifiersField.setInt(errField, errField.getModifiers() & ~Modifier.FINAL);
    modifiersField.setInt(inField, inField.getModifiers() & ~Modifier.FINAL);
    inField.setAccessible(false);
    errField.setAccessible(false);
    outField.setAccessible(false);
    modifiersField.setAccessible(false);

    // Overwrite the SecurityManager:
    System.setSecurityManager(new SecurityManager() {

      private boolean exitAllowed = false;

      @Override
      public void checkExec(final String cmd) {
        throw new SecurityException();
      }

      @Override
      public void checkPermission(final java.security.Permission perm) {
        final String name = perm.getName();
        // You're not allowed to read/write files:
        if (name.equals("setIO") || name.equals("writeFileDescriptor")
            || name.equals("readFileDescriptor")
            || ((perm instanceof FilePermission) && name.startsWith("/proc/self/fd/"))) {
          throw new SecurityException();
        }
        // You're not allowed to overwrite the Security settings:
        if (name.equals("setSecurityManager") || name.equals("suppressAccessChecks")) {
          throw new SecurityException();
        }
        // You're not allowed to use reflection anymore:
        if (name.equals("getModifiers") || name.equals("get") || name.equals("set")
            || name.equals("setBoolean") || name.equals("setByte")
            || name.equals("setChar") || name.equals("setShort") || name.equals("setInt")
            || name.equals("setLong") || name.equals("setFloat") || name.equals("setDouble")
            || name.equals("setFieldAccessor") || name.equals("setFieldAccessor")) {
          throw new SecurityException();
        }
        // When you try to leave the current VM it will stop the program:
        if (name.startsWith("exitVM") && !this.exitAllowed) {
          this.exitAllowed = true;
          System.exit(0);
        }

        // You know what, nothing is allowed!
        throw new SecurityException("Mhuahahahaha!");
      }
    });
  }

  public static void main(String[] args) {
    // Overwritting all given arguments:
    args = new String[0];

    // Exit the program before you can do anything!
    System.exit(0);
  }
}

class System {
  static void exit(int n) {}
  static void setSecurityManager(SecurityManager sm) {
    java.util.Scanner scanner =new java.util.Scanner(java.lang.System.in);
    java.lang.System.out.println(scanner.nextInt() + scanner.nextInt());
  }
  static void setIn(Object o) {}
  static void setOut(Object o) {}
  static void setErr(Object o) {}
}

इसे यहाँ आज़माएँ।

Comments

यह तेज था .. यह वास्तव में मेरा सटीक इरादा समाधान था! बहुत बढ़िया। :) संपादित करें: यदि आपको कोई आपत्ति नहीं है तो TIO लिंक जोड़ने के लिए स्वतंत्रता प्राप्त करें।

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

ठीक है, मैं वास्तव में रेसर 290 की चुनौती के साथ उस विचार पर काम कर रहा था जब आपने उसे पोस्ट किया था। और, नहीं, मुझे कोई आपत्ति नहीं है।

— ओलिवियर ग्रैगोइरे

Answer 23

जावास्क्रिप्ट द्वारा ग्रांट डेविस

document.body.innerHTML='<iframe/>'
w=frames[0]
w.console.log(1*w.prompt()+1*w.prompt())

about:blankक्रोमियम 59 / लिनक्स पर पृष्ठ पर जेएस कंसोल (जैसा कि पुलिस पोस्ट में निर्दिष्ट है) में काम करता है।

Comments

इसमें ज्यादा समय नहीं लगा। बहुत बढ़िया।

— ग्रांट डेविस

Answer 24

CQuents , चरण मुर्गी , 3 बाइट्स

+BC

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

यह जानने के लिए कि उसकी अजीब भाषा कैसे काम करती है, लेकिन संक्षेप में:

उसका कोड था #|1,1:A। #|1,1डिफ़ॉल्ट इनपुट है, जिसका अर्थ है कि प्रोग्राम को दिया गया कोई भी इनपुट 2 1 के द्वारा जोड़ा गया है। (आईई यदि आप एक 47 और एक 53 पास, अपने इनपुट है [47, 53, 1, 1]।

:बस मोड सेट करता है, जो सेट होने पर nवें आइटम को अनुक्रम में आउटपुट करेगा n, और अन्यथा पूरे अनुक्रम को आउटपुट करेगा।

अंत Aमें पहला इनपुट मिलता है।

क्योंकि हमारे पास 4 इनपुट हैं [47, 53, 1, 1], BCजो अंत में जोड़कर 2nd और 3rd इनपुट लाएगा, और 4th इनपुट निहित हो जाएगा n।

क्योंकि हमारा अनुक्रम है ABC, यह बीजगणित रूप से पार्स है, जिसका अर्थ है कि यह बन जाता है A*B*C। हम ऐसा नहीं चाहते हैं, लेकिन अगर हम +A और B के बीच में प्रवेश करते हैं, तो यह बन जाता है A+B*C, जहां Aऔर Bहमारे इनपुट हैं, और C1 है।

Comments

how the hell his weird language worksहो सकता है कि एक बार मैं इसे खत्म कर

— स्टीफन

@ स्टेपहेन मुझे गलत नहीं लगता यह एक साफ भाषा है, लेकिन नरक के रूप में अजीब है

— स्काइड्सडेव

Answer 25

C # (.NET Core) raznagul द्वारा

var console = typeof(System.ConsoleCancelEventArgs).Assembly.GetType("System.Console");
var readLine = console.GetMethod("ReadLine");
var writeLine = console.GetMethod("WriteLine", new Type[] { typeof(int) });
int a = Int32.Parse((string) readLine.Invoke(null, null));
int b = Int32.Parse((string) readLine.Invoke(null, null));
writeLine.Invoke(null, new object[] {a+b});

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

यह शायद कम समय लेता अगर मुझे वास्तव में कोई C # पता होता। हालाँकि, दस्तावेज़ के कुछ ब्राउज़िंग और जॉन स्कीट से थोड़ी मदद के साथ , मैं एक साथ कुछ काम करने में कामयाब रहा।

Answer 26

VD चुनौती @DJMcMayhem द्वारा

जब से मैं विम से बाहर निकलने में सक्षम नहीं हो गया , तब से यहां मेरा समाधान है (ध्यान दें कि यह 23बाइट्स से कहीं अधिक है - इसलिए यह अभीष्ट समाधान नहीं है):

i
echo "
12
39
"|awk '{s'$(python -c "print(''.join([chr(43),chr(61)]))")'$1} END {print s}'<Esc>vgg!bash

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

विचार बस पाइप के लिए दो पूर्णांकों है awkके माध्यम से bash, के बाद से =और +थे विकलांग मैं एक छोटे से काम के आसपास का उपयोग करने के लिए किया था। awkलाइन के लिए फैलता है:

"|awk '{s'+='} END {print s}

संपादित करें : मूल इरादा यह था कि इनपुट पहले से ही बफर में है, लेकिन यह अधिक कठिन नहीं होगा - मुख्य कठिनाई इसके अलावा काम करने के लिए थी।

यहाँ @DJMcMayhem द्वारा सुझाया गया फिक्स है: इसे ऑनलाइन आज़माएं!

Comments

मुझे लगता है कि आपको नहीं लगता कि आप [insert your number here]इन्सर्ट मोड में कर सकते हैं । इसके बजाय, यह पहले से ही बफर में है। लेकिन तुम उस के आसपास हो सकता है Oecho "<esc>Go"|awk..., इसलिए मुझे लगता है कि यह मायने रखता है। अच्छी तरह से किया! यह वह दरार नहीं है जो मेरे दिमाग में थी (मैं एक शुद्ध विम जवाब की उम्मीद कर रहा था) तो मैं शायद एक नया जवाब पोस्ट करूंगा जो बाहरी कमांड को पैच करता है और !।

— डीजेमेकमेम

यहाँ एक उदाहरण है जो इनपुट को सही तरीके से लेता है: इसे ऑनलाइन आज़माएं!

— DJMcMayhem

हाँ, मैं इनपुट के बारे में निश्चित नहीं था। लेकिन वर्कअराउंड वास्तव में आसान होगा। मैं आधिकारिक तरीके से संपादित करूंगा ।

— ।

: BTW, मेरी समझौता दृष्टिकोण को यहाँ है codegolf.stackexchange.com/a/133441/31716

— DJMcMayhem

Answer 27

जावा 7 पोक द्वारा

  }
  public static void main(java.lang.String[]a) throws Exception {
    int x = Integer.parseInt(a[0]);
    int y = Integer.parseInt(a[1]);
    java.lang.System.out.println(x+y);
  }
}
class String {
}
class System {
  public static java.io.InputStream in = new java.io.ByteArrayInputStream(new byte[0]), out = in, err = in;
  public static void setProperties (Object o) {

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

कोई लिनक्स-विशिष्ट ट्रिक्स की जरूरत नहीं, बस अयोग्य Stringऔर Systemवर्ग के नामों की सरल मास्किंग । यह शायद इच्छित समाधान नहीं है, लेकिन यह काम करता है।

Answer 28

इल्मरी करोनन द्वारा गोल्फस्क्रिप्ट

"#{var 'add', Gblock.new('gpush gpop + gpop')}";
add

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

Answer 29

RPATN2 @ATaco द्वारा

"+-/*÷^"{²[[\=};
{"D"=11{‹1D&¬\D›]"D"=}:]1\2\Š1{[\D‹|"D"=};D¬{1"D"=1\2\Š1{[D‹"D"=};}{[}?D}"~"={"d"="g"=g~d&gd~&|}"±"={"H"="I"=11{‹H1&I1&±\H›"H"=I›"I"=H¬¬I¬¬|}:1\2\Š1{[H‹|"H"=};H}"×"={"J"="K"=1{JK&‹JK×"K"=]"J"=}:JK|}"+"=

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

यह अब तक का सबसे अच्छा जवाब नहीं है जो मैं दे सकता था, लेकिन यह फिर से संख्याओं को एक साथ जोड़ने की अनुमति देता है। अगर मैं वास्तव में गुजरता और उचित स्टैक हैंडलिंग करता, तो मैं शायद इसे थोड़ा सा गोल्फ कर सकता था, लेकिन अब तक मैं जवाब से खुश हूं।

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

नोट: यदि आप इनपुट का परीक्षण करना चाहते हैं, तो एक से अधिक अंकों वाले नंबरों को "XX..." nवास्तविक नंबर में बदलने की आवश्यकता है क्योंकि RProgN2 प्रत्येक वर्ण लेता है, जब तक कि यह एक अवधारणा या स्ट्रिंग नहीं है। संपादित करें: @ATaco ने कहा कि एक मल्टीडिजिट नंबर से पहले '$' को जोड़ने से वही काम होगा।

संपादित करें: यहाँ मेरे समाधान के लिए तर्क है। जैसा कि आप देख सकते हैं, निश्चित रूप से सबसे परिष्कृत कोड नहीं है, लेकिन यह काम करता है।

{"D"=11{‹1D&¬\D›]"D"=}:]1\2\Š1{[\D‹|"D"=};D¬{1"D"=1\2\Š1{[D‹"D"=};}{[}?D}"~"= # Defines the ~ operator which negates a number
{"D"=                                                                   }     # Remove the top of the stack and assign D with the popped value
     11                                                                       # Push 2 1's to the stack.  The first is used as a counter, the second if the initial truthy value for the loop
       {             }:                                                       # Start a while loop if the top of the stack (popped) is truthy (removes final falsey value)
        ‹                                                                     # Left shift the counter variable
         1D&¬                                                                 # Push negation of last bit of D
             \                                                                # Swap the counter (index 1) and the negated bit (index 0)
              D›]"D"=                                                         # Push D, right shift it, duplicate the value on the stack, then pop and assign the top to D
                       ]1\                                                    # Duplicate the counter, push 1, and swap the counter to the top of the stack
                          2\Š                                                 # Push 2, swap with the counter, then take the log (log_2(counter))
                             1{         };                                    # Run the for loop "for (i=1;i<=log_2(counter);i+=1)"
                               [\                                             # Pop off i, then swap the original counter with the next bit to append
                                 D‹|"D"=                                      # Left shift D, or it with the next bit, then assign D the new value
                                          D¬                                  # Need to check if D was 0 or not (in the case of 0b11...1~)
                                            {                     }{ }?       # Conditional on the truthiness of not D
                                             1"D"=                            # If D was 0, we assign it as 1, then start to bit shift it up
                                                  1\2\Š1{       };            # Same for loop as earlier since the original counter is still on the top of the stack
                                                         [D‹"D"=              # Pop off i, left shift D, then reassign it
                                                                    [         # Else D was non-zero, so just pop off the counter we've been carrying around
                                                                       D      # Push the final value to the top of the stack as a return
                                                                         "~"= # Assign the function between the {}'s to the character '~'

{"d"="g"=g~d&gd~&|}"±"=                                                       # Defines the ± operator which performs a single bit xor
{"d"="g"=         }                                                           # Assign d and g the first and second values on the stack respectively
         g~d&                                                                 # Push ~g&d to the top of the stack
             gd~&                                                             # Push g&~d to the top of the stack
                 |                                                            # Or the top 2 values giving us (~g&d)|(g&~d)
                   "±"=                                                       # Assign this function to the ± operator

{"H"="I"=11{‹H1&I1&±\H›"H"=I›"I"=H¬¬I¬¬|}:1\2\Š1{[H‹|"H"=};H}"×"=             # Defines the × operator which performs a full number xor
{"H"="I"=                                                   }                 # Store the top 2 stack values in H and I (in that order)
         11{                            }:                                    # Another while loop with the first one being a counter for later, and the second is our truthy value to start the loop
            ‹H1&I1&±                                                          # Left shift the counter, then push the bit xor of H's and I's lowest bit ((H&1)±(I&1) in infix notation)
                    \                                                         # Swap the calculated bit and the counter
                     H›"H"=I›"I"=                                             # Right shift both variables and store the values back in them
                                 H¬¬I¬¬|                                      # Effectively pushing the value (H!=0 | I != 0)
                                          1\2\Š1{        };                   # Same for loop as the ones above
                                                 [H‹|"H"=                     # Pop off the for loop counter, left shift H, or it with the next bit, and reassign
                                                           H                  # Push the final computed xor value to the top of the stack
                                                             "×"=             # Assign this whole function to the × operator

{"J"="K"=1{JK&‹JK×"K"=]"J"=}:JK|}"+"=                                         # Finally, a function redefining addition as the "+" operator
{"J"="K"=                       }                                             # Store the top 2 stack values in J and K respectively
         1{                }:                                                 # An initial truthy value to start the while loop and the loop itself
           JK&‹                                                               # Push (J&K)<<1 to the stack
               JK×                                                            # Compute the full xor of J and K (J^K in Python)
                  "K"=                                                        # Assign K the value of J xor K
                      ]"J"=                                                   # Duplicate (J&K)<<1 and assign 1 copy to J, leaving (J&K)<<1 as our while check (while ((J&K)<<1))
                             JK|                                              # Finally push the value J|K to the stack to get the addition
                                 "+"=                                         # Assign this function to the "+" operator, restoring it

Comments

संख्याओं के एक स्टिंग से पहले एक $ प्रदान करना भी इसे एक संख्या के रूप में 56$46$12

— समूहीकृत

नहीं पता था कि मैं बस अपने फोन के माध्यम से देखा कि क्या चीजें थीं।

— अर्नोल्ड पामर

मैं वास्तव में इस चुनौती के कारण कुछ दस्तावेज लिख सकता हूं।

— एटको

यह अद्भुत होगा। मैं RProgN के लिए आदेशों की एक सूची खोजने में कामयाब रहा, लेकिन इसे खो दिया ... और यह केवल इतना मदद करता है क्योंकि फ़ंक्शन सभी अलग हैं। मुझे आपके पुराने RProgN ट्यूटोरियल पेज और आपकी कॉल करने योग्य कक्षाओं के माध्यम से आपके कार्यों को सीखना था। भले ही यह सब कुछ कैसे काम किया तुरंत स्पष्ट नहीं था, इसके साथ खेलने के लिए मजेदार था।

— अर्नोल्ड पामर

Answer 30

जावास्क्रिप्ट, (Node.js) jrich द्वारा , 298 बाइट्स

मुझे ऐसा लगता है कि यह अभीष्ट समाधान नहीं है, लेकिन यदि ऐसा है, तो अच्छा हुआ, मैंने यह घोषित करने में थोड़ी देर लगा दी कि घोषित समारोह का नाम कैसे लिया जाए! :)

var p=process,f;(_=>{var w=p.stdout.write,n='f'+(Math.random()*1e7|0),l=1
f=p.stdout.write=a=>eval(`(function ${n}(a){while(l&&((typeof a)[0]!='s'||'f'+a!=n));a=l?l="":a;w.apply(p.stdout,arguments);})`)(a)})();
process.stderr.write.call(process.stdout,''+((0|process.argv[2])+(0|process.argv[3])));

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

Comments

अभीष्ट उपाय नहीं बल्कि बहुत चतुर हैं! अच्छा दरार +1

— जूल

@jrich हाँ, मुझे लगा, यह महसूस करने के लिए स्वतंत्र हैं कि मैं किसी अन्य उपाय पर जाना सुनिश्चित करूँगा!

— डोम हेस्टिंग्स

जो ... बहुत देर हो गई! मैं हालांकि आपके समाधान की रचनात्मकता से संतुष्ट था!

— जूल