काफी ... लेकिन एक से स्थानांतरित कर दिया

15

दशमलव में मुद्रण योग्य ASCII वर्ण कोडों का जिक्र करते हुए, हम जानते हैं कि 32 से 126 तक हमारे पास 32 (अंतरिक्ष) होने के साथ मुद्रण योग्य वर्ण हैं। आपकी चुनौती केवल 32 से 125 (126 को छोड़कर) के पात्रों का उपयोग करके एक कार्यक्रम लिखना है, जिसे निष्पादित करते समय, अपने स्वयं के स्रोत कोड को प्रिंट करता है सिवाय इसके कि स्रोत कोड में प्रत्येक वर्ण का एक ASCII कोड एक से बढ़ गया है।

उदाहरण के लिए, यदि स्रोत कोड था

main(){printf("Hello World");}

इसका आउटपुट होगा

nbjo)*|qsjoug)#Ifmmp!Xpsme#*<~

निम्नलिखित निषिद्ध हैं:

  • किसी भी बाहरी फाइल या स्टोरेज को पढ़ना / लिखना / (इंटरनेट सहित)
  • अपने स्वयं के स्रोत कोड को पढ़ना / गूँजना
  • 2 से कम वर्णों वाले स्रोत कोड (वे मज़ेदार नहीं हैं)। 2 से अधिक या उसके बराबर होना चाहिए।

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

popularity-contest  quine 
— स्थिर केंद्र
स्रोत
126 की अनुमति क्यों नहीं है, लेकिन इसे 32 पर जाना है? (मुझे नहीं पता कि क्यों / कोई भी ऐसा कैसे करेगा।)
— जस्टिन
इस प्रकार के प्रश्नों को "आउटपुट" (क्षमा करें @GariBN) के रूप में माना जाने वाले त्रुटि संदेशों को भी मना करना चाहिए। "आउटपुट" सामान को जानबूझकर आपके कोड द्वारा मानक आउटपुट पर मुद्रित किया जाता है, न कि मनमाने ढंग से साइड इफेक्ट्स जो भाषा निष्पादन योग्य द्वारा निर्धारित किए जाते हैं।
— l0b0
3
~GolfScript के लिए वास्तव में बेकार का उपयोग करने में असमर्थता । शर्त पर तुमने ऐसा किया है। :-)
— इल्मरी करोनें
1
"अपने स्रोत कोड को पढ़ने" को परिभाषित करें। क्या हमें किसी फ़ंक्शन को सख्त करने की अनुमति है, या हमें इसके बजाय एक स्ट्रिंग को विकसित करना है?
— जॉन ड्वोरक
1
यह समस्या एक लोकप्रियता प्रतियोगिता के रूप में उपयुक्त नहीं लगती है।
— l4m2

जवाबों:

46

अजगर (27 अक्षर)

पायथन शेल में, निम्न स्क्रिप्ट वांछित परिणाम का उत्पादन करेगी:

TzoubyFssps;!jowbmje!tzouby

हाँ! यह आउटपुट:

SyntaxError: invalid syntax
— गारी बी.एन.
स्रोत
6
अरे यार, यह आते नहीं देखा। :-D
— फिक्स्ड प्वाइंट
9
वास्तव में परिणाम गलत तरीके से स्थानांतरित किया गया है: पी
— एरब्यूरथ का कहना है कि मोनिका
@Erbureth यह यहां कई अन्य उत्तरों के लिए भी प्रासंगिक है ... =)
— Gari BN
स्मार्ट चाल, हालांकि यह सबसे छोटा नहीं है। xD
— cjfaure
2
मैं ट्रोलोलोलोलोल कह रहा हूं।
— PyRulez
14

है ना? , 5 अक्षर

Ntbg

ध्यान दें कि 5 वें वर्ण के बाद का स्थान हैNtbg । यह मेरे पिछले उत्तरों में से एक के रूप में एक ही चाल है । Ntbgएक अमान्य पथ है, इसलिए दुभाषिया आउटपुट करेगा Ouch!आपको इसे इस तरह चलाना चाहिए:

huh.exe Ntbg
— ProgramFOX
स्रोत
मैं "हुह" के साथ कई quines की कल्पना कर सकता हूं? अभी। उलट Quine:! HcuO Quine: आउच!
— मिल्कीवेय 90
8

PHP (351)

मुझे यकीन है कि ऐसा करने का एक बेहतर तरीका है, क्योंकि मैं कोडगुल्फिंग के लिए नया हूं, लेकिन यहां मेरा PHP समाधान है:

function q(){$q=chr(39);$a=array('function q(){$q=chr(39);$a=array(',');@$r.=$a[0];foreach($a as$b)$r.=$q.$b.$q.",";$r=substr($r,0,-1);$r.=$a[1];for($i=0;$i<strlen($r);$i++)$r{$i}=chr(ord($r{$i})+1);return $r;}');@$r.=$a[0];foreach($a as$b)$r.=$q.$b.$q.",";$r=substr($r,0,-1);$r.=$a[1];for($i=0;$i<strlen($r);$i++)$r{$i}=chr(ord($r{$i})+1);return $r;}

आउटपुट:

gvodujpo!r)*|%r>dis)4:*<%b>bssbz)(gvodujpo!r)*|%r>dis)4:*<%b>bssbz)(-(*<A%s/>%b\1^<gpsfbdi)%b!bt%c*%s/>%r/%c/%r/#-#<%s>tvctus)%s-1-.2*<%s/>%b\2^<gps)%j>1<%j=tusmfo)%s*<%j,,*%s|%j~>dis)pse)%s|%j~*,2*<sfuvso!%s<~(*<A%s/>%b\1^<gpsfbdi)%b!bt%c*%s/>%r/%c/%r/#-#<%s>tvctus)%s-1-.2*<%s/>%b\2^<gps)%j>1<%j=tusmfo)%s*<%j,,*%s|%j~>dis)pse)%s|%j~*,2*<sfuvso!%s<~
— elixenide
स्रोत
6

TI-BASIC, 10

अपने TI-83/84 कैलकुलेटर के लिए!

DQQ9RXMS@W

आउटपुट:

ERR:SYNTAX
— Timtech
स्रोत
6

GolfScript, 15 वर्ण

{`{)}%"/2+"}.1*

आउटपुट:

|a|*~&#03,#~/2+

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

"घूमने वाली" चुनौती के लिए मेरी प्रविष्टि के लिए मैंने जिस तकनीक का उपयोग किया था, उसके आधार पर एक बिल्कुल सीधा समाधान । एक मुश्किल विस्तार यह है कि चरित्र ~(ASCII 126) चुनौती नियमों द्वारा अस्वीकृत है, इसलिए मैं अपने कोड ब्लॉक को निष्पादित करने के लिए इसका उपयोग नहीं कर सकता। सौभाग्य से, 1*इसका एक पर्याय के रूप में इस्तेमाल किया जा सकता है।

स्पष्टीकरण:

कोड ब्लॉक {`{)}%"/2+"}को डुप्लिकेट किया जाता है ., और दूसरी कॉपी 1*(तकनीकी रूप से, एक-पुनरावृति लूप) द्वारा निष्पादित की जाती है , दूसरी कॉपी को स्टैक पर छोड़ देता है। कोड ब्लॉक के अंदर, कोड ब्लॉक को `स्ट्रिंग करता है, और {)}%(प्रत्येक के ASCII कोड) इसके अक्षरों को एक-एक करके बढ़ाता है। अंत में, स्टैक पर "/2+"शाब्दिक स्ट्रिंग /2+(जिसे .1*एक के द्वारा स्थानांतरित किया जाता है) को धक्का देता है । कार्यक्रम के अंत में, गोल्फस्क्रिप्ट दुभाषिया फिर स्वचालित रूप से स्टैक पर सब कुछ प्रिंट करता है।

Ps। हां, मुझे पता है कि यह सख्त कोड-गोल्फ के बजाय एक लोकप्रियता-प्रतियोगिता है , लेकिन मैं गोल्फस्क्रिप्ट - ASIIII कला के साथ और क्या करने जा रहा हूं? ;-)

— इल्मरी करोनें
स्रोत
3

जावास्क्रिप्ट, 117 वर्ण

मुझे पता है कि यह कोड गोल्फ नहीं है, लेकिन मैंने इसे वैसे भी गोल्फ किया है।

function f(){alert((f+';f()').split('').map(function(x){return String.fromCharCode(x.charCodeAt()+1)}).join(''))};f()

(मैं अपना स्वयं का स्रोत कोड नहीं पढ़ रहा हूं; मैं केवल Functionऑब्जेक्ट के toStringफ़ंक्शन का उपयोग कर रहा हूं ।)

— Doorknob
स्रोत
2

जावा - 1331 बाइट्स, 618 बाइट्स और 504 बाइट्स

यहाँ यह जावा में है। अच्छी बात यह है कि यह काफी सुपाच्य और लचीला है। आप SHIFTचर को 0 में बदलने के लिए प्रयोग कर सकते हैं और यह एक क्वीन होगा। आप नकारात्मक मान सहित, जो भी चाहें उसे बदल सकते हैं और यह तदनुसार कोड को स्थानांतरित कर देगा।

public class Quinex {

    private static final int SHIFT = 1;

    private static String next(String now, boolean mangles) {
        String sb = "";
        for (char c : now.toCharArray()) {
            if (!mangles && c == 87) {
                sb += next(String.valueOf(SHIFT), true);
            } else {
                sb += (char) ((mangles ? c : c == 94 ? 10 : c == 64 ? 34 : c) + SHIFT);
            }
        }
        return sb;
    }

    public static void main(String... args) {
        System.out.println(next(TEXT, false) + next(TEXT, true) + new String(new char[] { 34, 59, 10, 125 }));
    }

    private static final String TEXT = "public class Quinex {^^    private static final int SHIFT = W;^^    private static String next(String now, boolean mangles) {^        String sb = @@;^        for (char c : now.toCharArray()) {^            if (!mangles && c == 87) {^                sb += next(String.valueOf(SHIFT), true);^            } else {^                sb += (char) ((mangles ? c : c == 94 ? 10 : c == 64 ? 34 : c) + SHIFT);^            }^        }^        return sb;^    }^^    public static void main(String... args) {^        System.out.println(next(TEXT, false) + next(TEXT, true) + new String(new char[] { 34, 59, 10, 125 }));^    }^^    private static final String TEXT = @";
}

हालांकि, पिछली कक्षा में एकमात्र खामी लाइन ब्रेक हैं, जो प्रश्न युक्ति में अनुमत नहीं हैं (सीमा 32 से 125 के बाहर हैं)। इसलिए मैं यहां एक गोल्फ संस्करण देता हूं जो लाइन ब्रेक से मुक्त है (और उन्हें संभालने के लिए quirks से मुक्त है)। Sपरिवर्तन को बदलने के लिए आप चर का मान संपादित कर सकते हैं । यह 618 बाइट्स है:

class Q{static String g(String p,int m){int S=1;String u="";for(char c:p.toCharArray()){if(m==0&&c==87){u+=g(String.valueOf(S),1);}else{u+=(char)((m>0?c:c==64?34:c)+S);}}return u;}public static void main(String[]y){System.out.println(g(T,0)+g(T,1)+new String(new char[]{34,59,125}));}static final String T="class Q{static String g(String p,int m){int S=W;String u=@@;for(char c:p.toCharArray()){if(m==0&&c==87){u+=g(String.valueOf(S),1);}else{u+=(char)((m>0?c:c==64?34:c)+S);}}return u;}public static void main(String[]y){System.out.println(g(T,0)+g(T,1)+new String(new char[]{34,59,125}));}static final String T=@";}

निश्चित रूप से, यदि हम ऑफ़सेट के ठीक समायोजन को छोड़ देते हैं और शिफ्ट के मूल्य को हार्डकोड करते हैं, तो हम 504 बाइट्स के साथ पूरी तरह से गोल्फ संस्करण कर सकते हैं:

class Q{static String g(String p,int m){String u="";for(char c:p.toCharArray()){u+=(char)((m>0?c:c==64?34:c)+1);}return u;}public static void main(String[]y){System.out.println(g(T,0)+g(T,1)+new String(new char[]{34,59,125}));}static final String T="class Q{static String g(String p,int m){String u=@@;for(char c:p.toCharArray()){u+=(char)((m>0?c:c==64?34:c)+1);}return u;}public static void main(String[]y){System.out.println(g(T,0)+g(T,1)+new String(new char[]{34,59,125}));}static final String T=@";}
— विक्टर स्टैफ़ुसा
स्रोत
1

पर्ल 5, 284 वर्णों में लाइनफ़ीड शामिल हैं

उपयोग करने की अनुमति नहीं दी जा रही है ~ इसे थोड़ा और मुश्किल बना दिया।

#!/usr/bin/perl
$_=<<X;
#!/usr/bin/perl
Y
\$a=\$_;
s/\\\\/\\\\\\\\/g;
s/\\\$/\\\\\\\$/g;
\$b=\$_;
\$_=\$a;
s/Y/\\\$\\_\\=\\<\\<X\\;\\n\${b}X/;
s/(.)/chr(ord(\$1)+1)/ge;
print;
X
$a=$_;
s/\\/\\\\/g;
s/\$/\\\$/g;
$b=$_;
$_=$a;
s/Y/\$\_\=\<\<X\;\n${b}X/;
s/(.)/chr(ord($1)+1)/ge;
print;
— स्टीफन मोंटगोमरी-स्मिथ
स्रोत
1

अजगर, ९९

s='import sys;sys.stdout.write("".join(chr(ord(c)+1)for c in a%(s,a)))';a='s=%r;a=%r;exec s';exec s

आउटपुट:

t>(jnqpsu!tzt<tzt/tuepvu/xsjuf)##/kpjo)dis)pse)d*,2*gps!d!jo!b&)t-b***(<b>(t>&s<b>&s<fyfd!t(<fyfd!t

इसे 75 वर्णों तक छोटा किया जा सकता है , लेकिन यह आउटपुट के बाद एक नई लाइन के चरित्र को प्रिंट करेगा, तकनीकी रूप से नियमों को तोड़ देगा:

s='print"".join(chr(ord(c)+1)for c in a%(s,a))';a='s=%r;a=%r;exec s';exec s
— gRC
स्रोत
1
आप \x09अंत में सिर्फ एक टैब ( ) क्यों नहीं डालते हैं , क्योंकि एक टैब को एक नई लाइन में स्थानांतरित कर दिया जाता है ( \x0A)। फिर आपका छोटा संस्करण 76 बाइट्स के साथ काम करेगा।
— mbomb007
0

लुआ - 192

बहुत सीधा,

s=[[print((('s=['..'['..s..']'..']'..s):gsub('.',function(x)return string.char(x:byte()+1)end)))]]print((('s=['..'['..s..']'..'];'..s):gsub('.',function(x)return string.char(x:byte()+1)end)))
— mniip
स्रोत
0

सी - 156

char*f="char*f=%c%s%c,q[200];i;main(){sprintf(q,f,34,f,34);while(q[i])q[i++]++;puts(q);}",q[200];i;main(){sprintf(q,f,34,f,34);while(q[i])q[i++]++;puts(q);}

आवश्यक संशोधनों के साथ बस क्लासिक सी क्वीन

पुनश्च, जाहिरा तौर sprintf(f,...,f,...)पर एक segfault है।

— mniip
स्रोत
0

जावास्क्रिप्ट (276)

उपयोग किए बिना .toString():

function q(){x=String.fromCharCode;y=x(39);a=['function q(){x=String.fromCharCode;y=x(39);a=[','];r=a[0]+y+a[0]+y+","+y+a[1]+y+a[1];q="";for(c in r)q+=x(r[c].charCodeAt(0)+1);return q;}'];r=a[0]+y+a[0]+y+","+y+a[1]+y+a[1];q="";for(c in r)q+=x(r[c].charCodeAt(0)+1);return q;}
— elixenide
स्रोत
0

रूबी, ६३

डारन, इस पर एक हेरेडोक का उपयोग नहीं किया जा सकता है।

s="s=%p;(s%%s).chars{|c|$><<c.succ}";(s%s).chars{|c|$><<c.succ}

रूबी के पास एक देशी तरीका है .succजो एक चरित्र पर ऐसा करता है, और एक नई लाइन के बिना मुद्रण के साथ मुद्रण की तुलना में कम है, इसलिए यह बड़े करीने से काम करता है।

— histocrat
स्रोत
0

सी, 153

main(a){char b[999];sprintf(b,a="main(a){char b[999];printf(a=%c%s%c,34,a,34);for(a=0;b[a];)b[a++]++;puts(b);}",34,a,34);for(a=0;b[a];)b[a++]++;puts(b);}

सी में क्लासिक क्वीन का एक और संशोधन ...

— वीएक्स
स्रोत
0

> <>, 16 बाइट्स

" r:2+l?!;1+o50.

यहाँ यह कोशिश करो!

यह कमोबेश केवल एक मानक क्वीन है> <> (बिना उपयोग किए) g निर्देश ) है। केवल अंतर यह है कि यह अपने स्वयं के स्रोत-कोड को नहीं पढ़ता है और प्रत्येक वर्ण को आउटपुट करने से पहले 1 से बढ़ाता है।

आउटपुट

#!s;3,m@"<2,p61/

* <<> , 15 बाइट्स (गैर-प्रतिस्पर्धात्मक)

" r:2+Ol?!;1+ou

यहाँ यह कोशिश करो!

— redstarcoder
स्रोत
1
— जो किंग
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.