31

এই মন্তব্য দ্বারা অনুপ্রাণিত ...

ব্যবহারকারীদের স্টেপ হেন , গম-উইজার্ড এবং ডেনিসকে পোস্ট করার আগে এই চ্যালেঞ্জের বিশদটি আরও দৃ solid়তর করতে সহায়তা করার জন্য ধন্যবাদ!

এটাই ডাকাত থ্রেড! কপসের থ্রেডের জন্য, এখানে যান

ইন এই প্রতিদ্বন্দ্বিতা , আপনি কিছু কোড যে চলমান সঙ্গে tasked হয় এটা এত আপনার ভাষা আর সন্তুষ্ট একটি প্রোগ্রামিং ভাষা হচ্ছে আমাদের মানদণ্ড যে। সেই চ্যালেঞ্জের মধ্যে, এর অর্থ এটি তৈরি করা যাতে ভাষা আর আর না করে ...

সংখ্যার ইনপুট এবং আউটপুট নিন
একসাথে দুটি সংখ্যা যুক্ত করুন
নির্দিষ্ট সংখ্যাটি মৌলিক কিনা তা পরীক্ষা করুন।

এটি একটি পুলিশ-ডাকাতদের চ্যালেঞ্জ, যেখানে দুটি পৃথক উদ্দেশ্য নিয়ে দুটি পৃথক চ্যালেঞ্জ রয়েছে: পুলিশরা এমন কিছু কোড লেখার চেষ্টা করবে যা ভাষাটিকে বেশিরভাগ অকেজো করে তোলে এবং ডাকাতরা পুলিশকে অনুমতি দেয় এমন লুকানো কাজের সন্ধানের চেষ্টা করবে তাদের ভাষা পুনরুদ্ধার করতে।

পুলিশরা কোডের দুটি স্নিপেট লিখবে:

একটি যা তাদের ভাষা বেশিরভাগ অকেজো করে তোলে, যেমন ইনপুট / আউটপুট এবং সংখ্যাসূচক ক্রিয়াকলাপগুলি গ্রহণের জন্য ফাংশনগুলিতে বিল্ট সরিয়ে দিয়ে। এই কোড করা হয় না বিপর্যস্ত বা প্রস্থানের অনুমতি দেওয়া। এই স্নিপেটের শেষে কোড যুক্ত করা সম্ভব হওয়া উচিত, এবং সেই কোডটি মূল্যায়ন করা হবে । এবং
কোডের স্নিপেট যা ইনপুট হিসাবে দুটি সংখ্যা নেয়, তাদের একসাথে যুক্ত করে এবং তাদের যোগফল বের করে। এই স্নিপেটটি অবশ্যই প্রথম স্নিপেট চালানোর পরেও সঠিকভাবে কাজ করবে। যখন দুটি স্নিপেট একসাথে একত্রিত হয়, তাদের অবশ্যই একটি সম্পূর্ণ প্রোগ্রাম তৈরি করতে হবে যা দুটি সংখ্যা যুক্ত করে, বা একটি ফাংশন সংজ্ঞা দেবে যা দুটি সংখ্যা যুক্ত করে। এই স্নিপেট সম্ভবত অস্পষ্ট আচরণের উপর নির্ভর করবে এবং এটি খুঁজে পাওয়া শক্ত হবে।

পুলিশরা ইনপুট এবং আউটপুটের কোনও মানক পদ্ধতিও চয়ন করবে । তবে, তারা অবশ্যই কোন ফর্ম্যাট (ইনপুট এবং আউটপুট) ব্যবহার করছে তা অবশ্যই প্রকাশ করতে হবে। তাদের উত্তর ক্র্যাক করার জন্য আপনাকে অবশ্যই একই ইনপুট / আউটপুট ফর্ম্যাটটি অনুসরণ করতে হবে, বা আপনার ক্র্যাকটি গণনা করছে না।

একটি পুলিশ উত্তর সর্বদা প্রকাশিত হবে

প্রথম স্নিপেট (স্পষ্টত দ্বিতীয়)।
ভাষা (ছোটখাট সংস্করণ সহ, যেহেতু বেশিরভাগ জমাগুলি সম্ভবত অদ্ভুত প্রান্তের ক্ষেত্রে নির্ভর করবে)
এটি ফাংশন বা পূর্ণ প্রোগ্রাম কিনা তা সহ আইও ফর্ম্যাট। ডাকাতের আবশ্যক একই বিন্যাস ব্যবহার করে একটি বৈধ ক্র্যাক যাবে।
কাজের উত্তর দেওয়ার জন্য যে কোনও অদ্ভুত প্রান্তের প্রয়োজন required উদাহরণস্বরূপ, শুধুমাত্র লিনাক্সের উপর চালিত হয় , বা একটি ইন্টারনেট সংযোগ প্রয়োজন ।

ডাকাত হিসাবে আপনাকে অবশ্যই একটি পুলিশ সাবমিশনের দিকে নজর দিতে হবে এবং এটি ক্র্যাক করার চেষ্টা করবে। স্নিপেট 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()
```
বৈধ নয় কারণ এটি ভাষা ভঙ্গ করে না। এটা সহজভাবে প্রস্থান।
সুরক্ষিত থাকার পরে, আপনার স্কোর হ'ল উভয় স্নিপকেটের বাইট গণনা ।
এটি আপনার কাজের উত্তরের জন্য প্রয়োজনীয় যে কোনও অদ্ভুত প্রান্তের কেসটি প্রকাশ করুন দয়া করে ফিরে যান ... আপনার জমাতে অবশ্যই প্রকাশিত হওয়ার পরে পুনরুত্পাদনযোগ্য হিসাবে প্রকাশের আগে পর্যাপ্ত তথ্য থাকতে হবে । এর অর্থ হ'ল যদি আপনার উত্তরটি নিরাপদ হয়ে যায় এবং তারপরে আপনি এডিট করেন: আমার উত্তর এখানে। ওহ হ্যাঁ, বিটিডাব্লু এটি কেবল তখনই কাজ করে যদি আপনি এটি সোলারিসে চালান, আপনার রসিকতা! আপনার উত্তরটি অবৈধ এবং মুছে ফেলা হবে এবং জয়ের যোগ্য হিসাবে বিবেচিত হবে না।
যোগফল আউটপুট করার পরে দ্বিতীয় স্নিপেটকে ক্র্যাশ করার অনুমতি দেওয়া হয়। যতক্ষণ না আউটপুটটি এখনও সঠিক থাকে (উদাহরণস্বরূপ, আপনি যদি এসটিডিআরআর থেকে আউটপুট চয়ন করেন, এবং তারপরে আপনি ক্র্যাশের তথ্য সংগ্রহ করেন তবে এটি অবৈধ)

লিডারবোর্ড

এখানে কমপক্ষে একটি ক্র্যাক সহ প্রতিটি ব্যবহারকারীর একটি তালিকা রয়েছে, স্কোর অনুসারে অর্ডার করা হয়েছে এবং তারপরে নাম (বর্ণানুক্রমিক)। আপনি যদি ক্র্যাক জমা দেন তবে অনুগ্রহ করে আপনার স্কোরটি আপডেট করুন।

#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

arithmetic cops-and-robbers

— ডিজেএমসিএমহেম
সূত্র

3

অলিভিয়ার গ্রাগোয়ারের জাভা 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সংখ্যার যোগ করা হবে to এটি হ'ল, উদাহরণস্বরূপ 17 এবং 25 সংখ্যা যুক্ত করার জন্য, প্রোগ্রামটি এইভাবে আহ্বান করা উচিত:

java -Dline.separator=17,25 Main

আমি বিশ্বাস করি কমান্ড লাইনে জাভা প্রোগ্রাম চালানোর চেয়ে কোনও সিস্টেমে কাজ করা উচিত। এমনকি যে সমস্ত সিস্টেমে কমান্ড লাইন নেই, সিস্টেম বৈশিষ্ট্য নির্ধারণের জন্য অন্য কোনও সমতুল্য প্রক্রিয়াটি ভিএম-তে ইনপুটটি পাস করার জন্য ব্যবহৃত হতে পারে।

গীত। এখানে আমার আগের ক্র্যাকিংয়ের প্রচেষ্টা, যা জেভিএম-নির্দিষ্ট বৈশিষ্ট্যগুলি ব্যবহারের কারণে অবৈধ বলে মনে করা হয়েছিল:

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." দিয়ে শুরু করে কোনও নেমস্পেসে বাস করে নি এর একটি সাবক্লাসটি সন্ধান করছিল । আমি সন্দেহ করি এটি এখনও উদ্দিষ্ট সমাধান নয়, তবে এটি কার্যকর *

^{*) টিআইও-তে, কমপক্ষে; sun.awt.AWTSecurityManagerশ্রেণী এবং sun.java.commandসম্পত্তি আনুষ্ঠানিকভাবে নথিভুক্ত করা হবে না বলে মনে হচ্ছে না, এবং সমস্ত JVMs উপলব্ধ নাও হতে পারে।}

— ইলমারি করোনেন
সূত্র

সুন্দর কাজ! আমি এটি চেষ্টা করেছিলাম, কিন্তু এমনটি খুঁজে পাচ্ছিল না SecurityManagerযা সুযোগের মধ্যে ছিল ... আপনি System.inএই মুহুর্ত থেকে এটি পড়তেও পারেন, যদিও এটি এখনও বন্ধ হয়নি।

— zbw

দুঃখিত, এটি দুটি শ্রদ্ধার উপর একটি প্ল্যাটফর্ম নির্ভর উত্তর: উভয়ই sun.awt.SecurityManagerএবং "sun.awt.command"প্ল্যাটফর্ম নির্ভর এবং জাভার অংশ নয় ।

— অলিভিয়ার গ্রাগোয়ার

হ্যাঁ, ফাটল! :) উদ্দেশ্য সমাধানটি ছিল System.getProperties().get("blah")(যেহেতু আমি কেবল অ্যাক্সেসকে অবরুদ্ধ করেছি System.getProperty, না System.getProperties), কিন্তু এটি যথেষ্ট ভাল! সাবাশ!

— অলিভিয়ার গ্রাগোয়ার

22

সি (জিসিসি / লিনাক্স) সিসিফাস

এই স্নিপেট সরবরাহিত ফাংশনটি বন্ধ করে এবং একটি নতুন (ক্লাসিক কোড ইঞ্জেকশন) শুরু করে, যা নিজেই পুনরায় সংজ্ঞা দেয় closeযাতে fd বন্ধ করার পরিবর্তে আমাদের পছন্দসই কোডটি চালায়।

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

  exit(0);

— 2012rcampion
সূত্র

20

পাইথন, গম উইজার্ডের সমাধান এখানে

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()))

আমার অর্থ, আপনি কেবল পুনরাবৃত্তি সীমাটি পিছনে সেট করতে পারেন, এবং খারাপ কিছু ঘটবে না ...

টিআইও-তে কাজ করে

বিঃদ্রঃ

এটি আমার প্রথম সিএনআর জমা, সুতরাং এটি যদি কোনও নিয়ম ভঙ্গ করে তবে দয়া করে আমাকে বলুন এবং আমি এটি মুছে ফেলব।

— HyperNeutrino
সূত্র

4

আমি এটি মিস করার জন্য বোবা

— গম উইজার্ড

@ হুইট উইজার্ড :)

— হাইপারনিউটারিনো

পছন্দ করেছেন আমি চাই খুউব পছন্দ আপনার মূল সমাধান সংশোধন করা হয়েছে এই সমস্যার সঙ্গে আরো ভালো পুলিস দেখতে।

— ডিজেএমসিএমহেম

@ ডিজেএমকামেহেম আমি সম্ভবত একটি ডেল সিস্ট নিয়ে পুনরায় পোস্ট করতে যাচ্ছি।

— গম উইজার্ড

@ ওয়েট উইজার্ড মনে রাখবেন os.sys, যদি তাতে কোনও পার্থক্য আসে: পি

— হাইপারনিউটারিনো

15

বেন দ্বারা হাস্কেল

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মতম উপাদানটি প্রদান করে । সাধারণত হিসাবে সংজ্ঞায়িত করা যেতে পারে । ফাংশনটি একটি তালিকা গ্রহণ করে এবং দশ পজিশনের দশকের পজিশনের উপাদানগুলির সাথে একটি তালিকা ফেরত দেয়। এর তম উপাদানটি প্রদান করে , যেখানে বিপরীত স্ট্রিং প্রতিনিধিত্ব । পৃথক হিসাবে দুটি প্রাকৃতিক সংখ্যার যোগকে বিপরীত স্ট্রিং হিসাবে প্রদান করে একইভাবে পার্থক্যের জন্য। সংখ্যার হিসাবে স্ট্রিং হিসাবে প্রদত্ত দুটি নেতিবাচক সংখ্যার যোগফল হিসাবে পূর্ণসংখ্যা হিসাবে প্রত্যাবর্তন করে।bnaxsnd.last.zipdl!!snlsn+-add

আমি ভাবছি বেনের মনে যা কিছু ছিল তা এর সাথে কিছুটা মিলে যায় কিনা।

— খ্রিস্টান সিভারস
সূত্র

হ্যাঁ, প্রায় একই ধারণা। সমতা পরীক্ষা এবং শাখা প্রশাখার জন্য আক্ষরিকের সাথে প্যাটার্ন ম্যাচিং, বর্ধনের একটি ফর্ম পেতে গণনা সিনট্যাক্সের তালিকা তৈরি করুন। আমি কিছুটা আমদানি করেও ছাড়াই :সুযোগ NoImplicitPreludeপেয়ে বেশ অবাক হয়েছি ।

— বেন

7

কনার ও ব্রায়েন দ্বারা সি (জিসিসি)


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

এটি অনলাইন চেষ্টা করুন!

— ডেনিস
সূত্র

ugggg আমি fscanf এবং অন্যান্য অনেকগুলি ফাংশন>।> ভাল কাজ নিষিদ্ধ করতে ভুলে গিয়েছিলাম

— কনর ও'ব্রায়ান

7

পাইথন 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 এর মতো মধ্যবর্তী মানগুলির জন্য subexpresstions লিখেছি এবং খালি স্ট্রিং এবং স্ট্রিং-এর পরিবর্তে এর মধ্যে রয়েছে।

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}'ফর্ম্যাটে আহরণের দ্বারা উত্পাদিত হয় {:}অভিধান হাজার স্ট্রিং reprs, সঙ্গে তৈরি করা থেকে অক্ষর dict। প্রতিটি ক্রমাগত সমন্ডের স্ট্রিং রিপ্রারটি যেখানে 5 থাকে সেখানে স্থাপন করা হয়। আমি {0:5}নিজের মতো একটি ডিক ব্যবহার করতে চেয়েছিলাম , তবে এর পুনর্নির্মাণের মধ্যে এমন একটি স্থান অন্তর্ভুক্ত রয়েছে যা এটি গোলমেলে ফেলেছে।

0 টি ইনপুটগুলি প্রক্রিয়াটি বিশৃঙ্খলা করে কারণ স্ট্রিং সাবটির সর্বনিম্ন দৈর্ঘ্য 1 থাকে We আমাদের কাছে যা আছে তাদের and/orএই ক্ষেত্রে খালি স্ট্রিং দেওয়ার জন্য।

— xnor
সূত্র

1

এটি আমার উদ্দেশ্য যা ছিল তার থেকে একেবারে আলাদা, আমি একটি ব্যাখ্যা দেখতে পছন্দ করব।

— গম উইজার্ড 13

উভয়ই আউটপুট আউট হিসাবে int([]in[])কেবল আপনার সমস্ত গল্ফ করতে পারেনint()

— মান কালি

5

হাসকেল, লাইকোনি দ্বারা

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

— বেন
সূত্র

5

জোশুয়া দ্বারা x x 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

ব্যাখ্যা:

জোশুয়ার কোড দ্বারা প্রবর্তিত "ব্রেক্সিট" হ'ল ট্র্যাপ ফ্ল্যাগের (টিএফ) সেটিংস, যা সিপিইউকে একক-পদক্ষেপে রাখে। এর অর্থ সিপিইউ টাইপ -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 বাধা দেওয়া হয়, সুতরাং যদি টিএফ সাফ করা না হয় , INT 1তবে নিজেই একটি বাধা সৃষ্টি করে — এটি পুরোপুরি বাধা হয়ে দাঁড়াবে। এছাড়াও, পরিষ্কার টিএফ-এ বাধা দেওয়া কেবল কোডটি ডিবাগ করা সহজ করে তোলে, অনেকটা আইডিইর মতো যা স্বয়ংক্রিয়ভাবে গ্রন্থাগার ফাংশনে কল করে।
পথ বিঘ্নিত কাজ মূলত একেবারেই হিসাবে একই 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। আমাদের যা করতে হবে তা হ'ল একসাথে দুটি সংখ্যা যুক্ত করা এবং ফলাফল মুদ্রণ করা। এটি অন্যান্য ভাষার ক্ষেত্রে যেমন সমাবেশের ভাষায় সহজ ততটা সহজ নয় তবে কোডের বেশিরভাগ অংশ এখানেই ব্যয় করা হয়।

জোশুয়া ডাকাতকে যে কোনও আই / ও মেকানিজম (গুলি) চান তা নির্দিষ্ট করার অনুমতি দিচ্ছে , তাই আমি মান ধরে নিয়েছি যে মানগুলি পাস হয়েছে DXএবংCX রেজিস্টার। এটি যুক্তিযুক্ত, যেহেতু এগুলি তার "প্রোলগ" কোড দ্বারা কোথাও আঁকড়ে নেই।

তারপরে আউটপুটটি সরাসরি এএসসিআইআই বাইটগুলি সরাসরি ভিডিও মেমোরিতে সংরক্ষণ করে। ভিডিও বাফারটি 0xB800:0000একটি পাঠ্য-মোড সিজিএ, ইজিএ এবং / বা ভিজিএ থেকে শুরু হয়, সুতরাং আমরা সেখানে মুদ্রণ শুরু করি। ফর্ম্যাটটি হ'ল: নিম্ন বাইটে অক্ষর, এবং উচ্চ বাইটে রঙের বৈশিষ্ট্য। তার মানে প্রতিটি অক্ষর 2-বাইট অফসেটে রয়েছে। আমরা কেবল সংখ্যার (বেস -10) প্রতিটি অঙ্কের মাধ্যমে পুনরাবৃত্তি করি, এগুলি ASCII এ রূপান্তর করি এবং একবারে স্ক্রিনে সেগুলি মুদ্রণ করি। হ্যাঁ, এটি প্রচুর কোড। সমাবেশ ভাষায় আমাদের সহায়তার জন্য কোনও লাইব্রেরি ফাংশন নেই। এটি প্রায় অবশ্যই আরও অনুকূলিত করা যেতে পারে, তবে আমি এতে কাজ করে ক্লান্ত হয়ে পড়েছি ...

আউটপুট প্রদর্শিত হওয়ার পরে, কোডটি ক্রাশ বা যা কিছু করার অনুমতি দেওয়া হয়, তাই আমরা কেবল বাধা পরিষ্কার করি এবং সিপিইউ বন্ধ করি।

— Cody Gray
সূত্র

I'm puzzled; I can't figure out how this gets past the hlt instruction at BP:SP+1.

— Joshua

@Joshua Hmm, that's a good point. I didn't even think about that. Stepping through the code in Debug, I execute INT 3 and end up immediately back at the instruction following it, so I just went with it. Maybe has something to do with my testing environment? CLI would only disable hardware interrupts, but even if it got past the HLT, you'd think it would fall through and execute the code in l immediately thereafter.

— Cody Gray

Oh, you were single stepping. Yeah that would do it. I'm going to double check but I think I uploaded whacked code.

— Joshua

I also tested without single-stepping. No difference. This is on FreeDOS latest in VM Virtualbox. I have real hardware available, but didn't feel like powering it up. @Joshua

— Cody Gray

Well you clearly cracked it then. Maybe you found a way to raise that NMI.

— Joshua

4

Python 2 by TwiNight


print input()+input() #

Try it online!

— Dennis
সূত্র

Dammit! Forgot about this. Time for a new answer then.

— TwiNight

4

Python 3, ppperry's 2nd Challenge

Wow, this was fun! I enjoyed solving this.

Edit: OK, I fixed it. It seems like the classes were at a different index in the subclass list on TIO than on my computer, so I made it work for both, and added a TIO.

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()

Try it online!

— zbw
সূত্র

I get an error. sys.excepthook is missing?

— Rɪᴋᴇʀ

Hmm... works for me. What's the real error you're getting? (That's happening because ppperry's code destroyed pretty much everything, including knowing how to show exceptions, so that's the sys.excepthook, but there'll be a real cause listed somewhere in there.)

— zbw

Nevermind, the real error is IndexError('list index out of range',). It's on the line with the definition of _io_RawIOBase.

— Rɪᴋᴇʀ

The problem is that the order of the subclasses isn't fixed. _io_IOBase = [cls for cls in object.__subclasses__() if cls.__name__ == '_IOBase'][0] should work everywhere.

— Dennis

@Dennis Yep, I realized that and just fixed it. It works on TIO now!

— zbw

4

Haskell by 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 )

Can't run code at run-time? Run it at compile time!

This was a lot of fun, I did not know template haskell before this challenge.

— BlackCap
সূত্র

3

Jelly by hyper neutrino

Super simple. The Newline causes the first link to not be called.

Try it online!

— DJMcMayhem
সূত্র

You could also adhere to the no newline rule like this

— Jonathan Allan

Yup, I thought this would be too easy.

— HyperNeutrino

3

Python 2 by Wheat Wizard

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

Try it online!

— Sisyphus
সূত্র

This is turning out to be more difficult than I thought.

— Wheat Wizard

3

Java by LordFarquaad

Blocking the access to the objects at the source level was really smart (and annoying when testing), well done!

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 {}
}

— Olivier Grégoire
সূত্র

Nice! What if ClassLoader had been shadowed?

— Jakob

1

@JakobCornell "".getClass().getClassLoader(). Shadowing is usually only a problem you have to think about once and then it's ok. You could even shadow Object, I'd still be able to solve this. Ok, you might force me into the 1kb solution, but it's possible.

— Olivier Grégoire

3

Ruby by histocrat


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

Try it online!

— Dennis
সূত্র

3

Inform 7, by Ilmari Karonen

Blantant abuse of ambiguous nouns ... My code begins with factory is a room. The previous line is the cop's code. Type add 1 and 1 to get 2, for example.

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;

— pppery
সূত্র

2

Java, Roman Gräf

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

Sets stdout and stderr back to their initial values.

I believe I am able to use the fully qualified name instead of an import, if I am wrong please correct me (this is my first post here.) This could probably be done using reflection as well.

Edit: here's a reflective solution using only 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) {
        }
    }
}

— Moira
সূত্র

Yep, stdin, stdout and stderr are stored elsewhere! You don't even need to use setOut and setErr as you can simply use the PrintStream directly.

— Olivier Grégoire

Added reflective solution as well as I feel this was what was initially expected

— Moira

2

JavaScript by Daniel Franklin

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

This might be considered a slightly cheaty solution, but it does work for me on Chromium 59 / Linux, even if I do also receive a warning saying:

Upcoming versions will block content-initiated top frame navigations to data: URLs. For more information, see https://goo.gl/BaZAea.

Ps. Here's another crack, this time without warnings:

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

— Ilmari Karonen
সূত্র

I think prompt()- -prompt() saves two bytes

— Marie

2

Java 8 by Olivier Grégoire

A hugely verbose crack for a hugely verbose challenge. :) The pain of working indirectly with classes that you cannot name is palpable.

    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;

Try it online!

Ps. Here's my earlier attempt, written before Olivier clarified that input was meant to be taken via command line arguments. Unlike the crack above, this one isn't Linux-specific.

    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;

Try it online!

— Ilmari Karonen
সূত্র

If you're up for it, here's my new challenge.

— Olivier Grégoire

Just for the sake of writing it here: since I have not the right to say "Gotcha! It works only on one system", this answer doesn't entirely crack the challenge because it works only on Linux.

— Olivier Grégoire

@OlivierGrégoire: FWIW, I did come up with an alternative solution using String[] args = ((String) system.getMethod("getProperty", String.class).invoke(null, "sun.java.command")).split(" "); that isn't Linux-specific, but does use what appears to be an undocumented property set by some JVMs.

— Ilmari Karonen

That's still not portable. It won't work on IBM Java, for instance. However, it's a nice idea! :)

— Olivier Grégoire

2

C# (.NET Core) by raznagul

I assume this wasn't the intended solution.

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

— Joshua
সূত্র

Nice trick with /dev/std* there. I initially aimed for a similar approach, but couldn't find any easy way to open streams for stdin/out without access to System.Console, so I opted for reflection instead. Of course, your solution presumably only works on Linux and other Unixish systems with the appropriate /dev entries, but raznagul didn't explicitly say it had to work on Windows. And it does work on TIO.

— Ilmari Karonen

@IlmariKaronen: Indeed; and my plan for if it were Windows would have failed on TIO.

— Joshua

1

Java, by racer290

This was rather a basic overlook that static initializers are called before the main method. It was a nice try: I was dismayed by the throw new Error() at first, but found the way in the end ;)

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
}

— Olivier Grégoire
সূত্র

System.out.println("Hello World!"); Doesn't add two integers?.. "2. A snippet of code that takes two numbers as input, adds them together, and outputs their sum. This snippet must still correctly function even after running the first snippet. When the two snippets are combined together, they must form a full program that adds two numbers, or define a function that adds two numbers. This snippet will probably rely upon obscure behavior, and be hard to find."

— Kevin Cruijssen

@KevinCruijssen What can I say? If the cops don't do their job, why should I do theirs? :P

— Olivier Grégoire

1

@KevinCruijssen There, I put an addition in there.

— Olivier Grégoire

@OlivierGrégoire the whole point is to prevent adding numbers, whether by removing the capability to input, to add, or to output.

— Stephen

@StepHen Yep, I understood it a bit more afterwards. Check my 3 other cracks to see that I finally understood that ;)

— Olivier Grégoire

1

Java by Kevin Cruijssen

Well constructed. A lot of code to make anyone properly ponder how to solve this challenge. I guess the "put your code afterwards" was a big, big hint.

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

Try it here.

— Olivier Grégoire
সূত্র

That was fast.. That was indeed my exact intended solution! Well done. :) EDIT: Took the liberty to add the TIO link if you don't mind.

— Kevin Cruijssen

Well, I was actually working on that idea with racer 290's challenge when you posted yours. And, no I don't mind.

— Olivier Grégoire

1

JavaScript by Grant Davis

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

Works in the JS console on the about:blank page (as specified in the cop post) on Chromium 59 / Linux.

— Ilmari Karonen
সূত্র

That didn't take long. Good Job.

— Grant Davis

1

cQuents, Step Hen, 3 bytes

+BC

Try it online!

Took a lot of talking to Step Hen to figure out how the hell his weird language works, but in short:

His code was #|1,1:A. #|1,1 is the default input, meaning any input given to the program is appended by 2 1's. (IE if you pass a 47 and a 53, your input is [47, 53, 1, 1].

: simply sets the mode, which will output the nth item in the sequence if n is set, and otherwise output the entire sequence.

Finally A gets the first input.

Because we have 4 inputs [47, 53, 1, 1], adding BC to the end would also fetch the 2nd and 3rd input, and the 4th input implicitly becomes n.

Because our sequence is ABC, it's parsed algebraically, meaning it becomes A*B*C. We don't want that, but if we insert a + between A and B, it becomes A+B*C, where A and B are our inputs, and C is 1.

— Skidsdev
সূত্র

how the hell his weird language works maybe once I finish it it might make some more sense

— Stephen

@StepHen don't get me wrong it's a neat language, but weird as hell

— Skidsdev

1

C# (.NET Core) by 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});

Try it online!

This would probably have taken less time if I actually knew any C#. However, with some browsing of the documentation and a bit of help from Jon Skeet, I managed to cobble together something that works.

— Ilmari Karonen
সূত্র

1

Vim challenge by @DJMcMayhem

It's been a while since I wasn't able to exit vim, here's my solution (note it's far more than 23 bytes - so it's probably not the intended solution):

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

Try it online!

The idea is simply to pipe the two integers to awk via bash, since = and + were disabled I had to use a small work-around. The awk line expands to:

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

Edit: The original intention was that the input is already in the buffer, but that wouldn't be more difficult - the main difficulty was to get addition working.

Here's the suggested fix by @DJMcMayhem: Try it online!

— ბიმო
সূত্র

I think don't think you can do [insert your number here] in insert mode. Instead, it's just already in the buffer. But you could get around that with Oecho "<esc>Go"|awk..., so I think this counts. Nicely done! This isn't the crack I had in mind (I was hoping for a pure vim answer) so I'll probably post a new answer that patches external commands and !.

— DJMcMayhem

1

Here's an example that takes input the correct way: Try it online!

— DJMcMayhem

Yeah, I wasn't sure about the input. But the workaround would indeed be easy. I'll edit in the official way.

— ბიმო

BTW, my patched approach is up here: codegolf.stackexchange.com/a/133441/31716

— DJMcMayhem

1

Java 7 by Poke

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

Try it online!

No Linux-specific tricks needed, just simple masking of the unqualified String and System class names. This is probably not the intended solution, but it works.

— Ilmari Karonen
সূত্র

1

GolfScript by Ilmari Karonen

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

Try it online!

— Dennis
সূত্র

1

RProgN2 by @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|}"+"=

Try it online!

This is by far not the best answer I could've given, but it allows adding numbers together again. Had I actually went through and did proper stack handling, I could probably golf this quite a bit, but as of now I'm happy with the answer.

In ATaco's original post he effectively just reassigned all of the main arithmetic operators to destroy their inputs. To fix this problem I redefined what addition was in terms of its binary operations, which was a pain because RProgN2 doesn't have a binary negation operator or xor.

Note: If you want to test the input, numbers with more than one digit need to be in the form "XX..." n to be converted into an actual number since RProgN2 takes each character as is unless it's a concept or string. Edit: @ATaco noted that adding a '$' before a multidigit number will do the same thing.

EDIT: Here is the logic for my solution. As you can see, most definitely not the most refined code, but it works.

{"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

— Arnold Palmer
সূত্র

Providing a $ before a sting of numbers also groups it as one number, e.g. 56$46$12 will push the numbers 5, 6, 46 and 12. I'll post my actual solution and such tommorow

— ATaco

Didn't know that. I sort of just looked through your callables to figure out what things were.

— Arnold Palmer

I might actually write some documentation because of this challenge.

— ATaco

That'd be wonderful. I managed to find a list of commands for RProgN, but lost it... And it only helped so much since the functions are all different. I had to learn your functions via your old RProgN tutorial page and your callable classes. It was fun to play around with even if it wasn't immediately obvious how everything worked.

— Arnold Palmer

1

JavaScript (Node.js) by jrich, 298 bytes

I feel like this isn't the intended solution, but if it is, well done, I spent a while trying to figure out how to get the name of the declared function! :)

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

Try it online!

— Dom Hastings
সূত্র

1

Not the intended solution but very clever! Nice crack +1

— jrich

@jrich Yeah, I figured, feel free to patch that out I'll be sure to have another go at the intended solution!

— Dom Hastings

whoops... too late! I was satisfied with your solution's creativity though!

— jrich

আপনার ভাষা * বেশিরভাগ * অকেজো (রবার থ্রেড) করুন

পাইথন ঘ

বিধি স্পষ্টতা

লিডারবোর্ড

পাইথন, গম উইজার্ডের সমাধান এখানে

বিঃদ্রঃ

বেন দ্বারা হাস্কেল

পাইথন 2 গম উইজার্ড দ্বারা (চতুর্থ পুনরাবৃত্তি)

Python 3, ppperry's 2nd Challenge

Haskell by zbw

cQuents, Step Hen, 3 bytes

JavaScript (Node.js) by jrich, 298 bytes