चुनौती

कोड के सबसे छोटे स्निपेट को इस तरह लिखिए कि, जब इसकी एन कॉपियों को एक साथ समेटा जाए, तो वर्ण आउटपुट की संख्या एन ^{2 हो जाती है} । एन एक सकारात्मक पूर्णांक होगा।

उदाहरण के लिए अगर स्निपेट था soln();, तो रनिंग soln();वास्तव में 1 वर्ण soln();soln();को प्रिंट करेगा , और रनिंग बिल्कुल 4 वर्णों soln();soln();soln();को प्रिंट करेगा , और रनिंग बिल्कुल 9 वर्णों को प्रिंट करेगा, आदि।

कोई भी वर्ण आउटपुट में हो सकता है जब तक कि वर्णों की कुल संख्या सही हो। क्रॉस-ओएस भ्रम से बचने के लिए, नए \r\nवर्णों को एक चरित्र के रूप में गिना जाता है।

कार्यक्रम अपने स्वयं के स्रोत को नहीं पढ़ सकते हैं या उनके फ़ाइल आकार को पढ़ सकते हैं या इस तरह के अन्य खामियों का उपयोग कर सकते हैं। इसे एक सख्त क्वीन चैलेंज की तरह ट्रीट करें ।

आउटपुट स्टडआउट या एक फ़ाइल या इसी तरह के विकल्प पर जा सकता है। कोई इनपुट नहीं है।

कोड में टिप्पणियाँ ठीक हैं, जैसा कि मध्य-निष्पादन से बाहर है।

कार्यक्रम में कोई भी पात्र हो सकता है। बाइट्स में सबसे कम सबमिशन जीतता है।

code-golf quine source-layout

— केल्विन के शौक
स्रोत

क्या कार्यक्रम को समाप्त करना है?

— मार्टिन एंडर

@ मार्टिनबटनर हां

— केल्विन के शौक

24

टीईसीओ, 4 बाइट्स

V1\V

Vपाठ बफ़र में वर्तमान लाइन की सामग्री को प्रिंट करता है। 1\वर्तमान स्थिति में नंबर 1 के स्ट्रिंग प्रतिनिधित्व को सम्मिलित करता है।

इसलिए कार्यक्रम के एन वें पुनरावृत्ति पर, पहले वर्ण का एन - 1 प्रतियां Vआउटपुट करेगा , फिर पाठ में एक और जोड़ें , फिर आउटपुट एन एस।11 1

— feersum
स्रोत

1

क्या आप TECO से लिंक जोड़ सकते हैं?

— एरिक आउटगोल्फर

22

ब्रेनफक, 17 16 बाइट्स

[>+>-..+<<-]-.>+

आप इसे यहाँ परीक्षण कर सकते हैं । बस इस तथ्य का उपयोग करें कि ।n²+2n+1=(n+1)²

— alephalpha
स्रोत

16

मुझे विश्वास नहीं हो रहा है कि मैं बीएफ को बाइट्स के प्रतिस्पर्धी स्तर पर देख रहा हूं!

— अग्वेबर

21

ब्रेनफक, 11

मैं पहले Brainfuck जवाब देखा और सोचा कि यह बहुत लंबा रास्ता है :)

[.<]>[.>]+.

आउटपुट को यह देखना आसान हो सकता है कि क्या आप प्लस को बहुत अधिक प्लस से बदलते हैं।

Nth पुनरावृत्ति पर, प्रत्येक लूप ASCII मान 1 के साथ वर्ण की N - 1 प्रतियां आउटपुट करता है, और उसके बाद एक और +.।

— feersum
स्रोत

आपको N ^ 2 वर्ण प्रिंट करने की आवश्यकता है, न कि N अक्षर। मैं BF कोड नहीं पढ़ सकता, इसलिए मुझे नहीं पता कि आपका कोड गलत है या यदि आपका विवरण गलत है।

— ब्रायन जे

@BrianJ यह N ^ 2 वर्ण प्रिंट करता है। आप इसे यहाँ देख सकते हैं: copy.sh/brainfuck यदि आप आउटपुट नहीं देख सकते हैं तो प्लस को माइनस से बदलें।

— एलेफ़लफा

@alephalpha उफ़, अब मैं देख रहा हूं कि मैंने टिप्पणी को गलत बताया। कोड ऐसा नहीं करता है (एन - 1) + 1 जैसा मैंने मूल रूप से सोचा था।

— ब्रायन जे

16

अजगर 2, 22

a='';print a;a+='xx';a

खाली स्ट्रिंग प्रिंट करता है, फिर दो xका, फिर x'चार और'। प्रत्येक स्ट्रिंग के बाद नई रेखा के साथ, यह n*nपात्रों के लिए आता है ।

एक प्रति: "\n"(१ चार)
दो प्रतियां: "\nxx\n"(४ चार्ट)
तीन प्रतियां: "\nxx\nxxxx\n"(९ चार्ट)

In order to stop the initial variable a from being reinitialized each run, I end the code with a ;a, which is benign on its own, but combined with the next loop to create the scapegoat aa to be assigned instead. This trick isn't mine; I saw it in a previous answer. I'd appreciate if someone could point me so I could give credit.

— xnor
स्रोत

Actually, is the final newline printed?

— xnor

no I don't think the final newline is printed. But simply removing the , after print a should work. print a prints a newline after each print.

— Justin

@Quincunx Oh, of course, thanks!

— xnor

Are you talking about this post?

— Sp3000

10

CJam, 6 bytes

LLS+:L

Uses the fact that n² + n + (n+1) = (n+1)².

L      "Push L. Initially this is an empty string, but its length increases by 1 with each copy
        of the snippet.";
 L     "Push another L.";
  S+   "Add a space to the second copy.";
    :L "Store the lengthened string in L for the next copy of the snippet.";

— Martin Ender
स्रोत

:L..1+ is the same idea in GolfScript.

— Peter Taylor

@PeterTaylor I was thinking ..n+ in GolfScript, but that pesky trailing newline... :(

— Martin Ender

Hah, you're right. No need for :L because it's not used.

— Peter Taylor

10

///, 21 bytes

I'm sure there is a really short and twisted way to solve this in /// but I couldn't find anything, beyond the "straightforward" way yet:

1/1\//112\///2\//1\//

This is based on the approach of printing consecutive odd numbers. The snippet consists of a 1 at the start which is printed, and two replacements which add two more 1s to that first part of each consecutive copy of the snippet. Let's go through this for N = 3. The following should be read in groups of 3 or more lines: 1. the current code, 2. the processed token(s), 3. (and following) a comment what the above token does.

1/1\//112\///2\//1\//1/1\//112\///2\//1\//1/1\//112\///2\//1\//
1
is printed
/1\//112\///2\//1\//1/1\//112\///2\//1\//1/1\//112\///2\//1\//
/1\//112\//
replaces all occurrences of 1/ with 112/. This affects the starts of all further snippets
but not the substitution commands, because the slashes in those are always escaped.
It is necessary to put a 2 in there, because otherwise the interpreter goes into an infinite
loop replacing the resulting 1/ again and again.
/2\//1\//112/1\//112\///2\//1\//112/1\//112\///2\//1\//
/2\//1\//
Replace all occurrences of 2/ with 1/, so the the next snippets substitution works again.
111/1\//112\///2\//1\//111/1\//112\///2\//1\//
111
is printed
/1\//112\///2\//1\//111/1\//112\///2\//1\//
/1\//112\//
add two 1s again
/2\//1\//11112/1\//112\///2\//1\//
/2\//1\//
turn the 2 into a 1 again
11111/1\//112\///2\//1\//
11111
print 11111
/1\//112\///2\//1\//
the last two substitutions have nothing to substitute so they do nothing

Interestingly, it works just as well if we move the 1 to the end:

/1\//112\///2\//1\//1

— Martin Ender
स्रोत

7

><>, 14 bytes

1:na*a*';'10p!

Uses the "sum of consecutive odd integers starting from 1" idea. It starts off with 1 and multiplies it by 100 each time, increasing the length of the output progressively by increments of 2.

For example, appending 5 copies gives

1100100001000000100000000

I tested by piping the output to a file, and didn't see a trailing newline.

Breakdown

1                   Push 1, skipped by ! every time except the first
 :n                 Copy top of stack and output as num                  
   a*a*             Multiply by 10 twice
       ';'10p       Modify the source code so that the first : becomes a ; for termination
             !      Skip the next 1

— Sp3000
स्रोत

5

CJam, 10 9 bytes

],)_S*a*~

This prints N² spaces where N is the number of copies of the code.

Code eexpansion:

],            "Wrap everything on stack and take length";
  )_          "Increment and take copy";
    S*        "Get that length space string";
      a*      "Wrap that space string in an array and create that many copies";
        ~     "Unwrap so that next code can use to get length";

Try it online here

— Optimizer
स्रोत

5

Python 2, 20 bytes

g=0
print'g'*g;g+=2#

— feersum
स्रोत

5

Java - 91 bytes

{String s=System.getProperty("a","");System.out.println(s);System.setProperty("a","xx"+s);}

This solution is equivalent to this other one in Python. It surely won't win, but it was fun :)

— cygnusv
स्रोत

Don't you need a class to run anything?

No, since OP asked for snippets of code. We can assume this is running inside a main, for example.

— cygnusv

Then I have a 59 or even 44 byte solution.

Cool :) I prefer one-liners, but yours is indeed shorter!

— cygnusv

4

Perl, 14 bytes

print;s//__/;

This needs to be run with Perl's -l command switch, which causes print to append new lines.

It prints the default variable $_, then prepends two underscores via substitution.

Example:

$ perl -le 'print;s//__/;print;s//__/;print;s//__/;print;s//__/;'

__
____
______

— grc
स्रोत

flags are counted as 1 more byte per flag

— Optimizer

What about say?

— hmatt1

@chilemagic I tried that, but I couldn't get it working on my versions of Perl.

— grc

@grc it's version 5.10 and higher and you need -E instead.

— hmatt1

@chilemagic hmm, that didn't seem to work for me on 5.16.

— grc

4

Brainfuck, 10 chars

Both previous Brainfuck solutions were waaay too long (16 and 11 chars) so here is a shorter one:

+[.->+<]>+

In the n-th block it prints out 2*n-1 characters (with codepoints from 2*n-1 to 1)

— randomra
स्रोत

2

This wouldn't work in standard brainfuck, only if the cells are unlimited-size. Actually, it wouldn't totally make sense then either. How do you output character code 1 trillion?

— feersum

3

Prelude, 18 12 bytes

^1+(9!1-)#2+

This prints N² tabs. It assumes a standard-compliant interpreter which prints characters instead of numbers, so if you use the Python interpreter you'll need to set NUMERIC_OUTPUT to False.

The idea is simply to use the top of the stack (which is initially 0) as 2(N-1), and print 2N-1 tabs, then increment the top of the stack by 2. Hence each repetition prints the next odd number of tabs.

— Martin Ender
स्रोत

3

Java - 59 / 44 (depending on requirements)

static String n="1";
static{System.out.print(n);n+="11";}//

Apparently we're allowed to assume code runs in a class.

If it can go inside a main method:

String n="1";
System.out.print(n);n+="11";//

3

C, 87 bytes

#if!__COUNTER__
#include __FILE__
main(a){a=__COUNTER__-1;printf("%*d",a*a,0);}
#endif

This uses two magic macros. __COUNTER__ is a macro that expands to 0 the first time it is used, 1 the second, etc. It is a compiler extension, but is available in both gcc, clang, and Visual Studio at least. __FILE__ is the name of the source file. Including a file in C/C++ is literally the same as pasting it directly into your source code, so it was a little tricky to make use of.

It would still be possible to use this technique without __COUNTER__. In that case, the standard guard against using code twice could be used for the #if statement, and __LINE__ could be used to count the number of characters needed.

— feersum
स्रोत

This solution is not written in C, but rather a C dialect. Please correct the language name.

— FUZxxl

2

@FUZxxl Most code-golf answers are only designed to work in gcc, so I'm not sure why this would be an issue.

— feersum

It isn't, but you should really declare that.

— FUZxxl

I'm confused. Why declare a non-issue? O_o

— corsiKa

@corsiKa It's only a non-issue if you declare it. The C gcc speaks is not standard C.

— FUZxxl

2

Dyalog APL, 20 19 bytes

A matrix based solution.

{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'

Try it here. Returns a string of N² repetitions of a. Explanation by explosion for N = 2:

{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'
                                  ⍪'a'  Wrap 'a' into a 1x1 matrix.
                'a'{            }⍨      Binary function: bind 'a' to ⍵ and the matrix to ⍺.
                    ⍺≢⍵:                The arguments are not identical,
                        ⍵⍪⍵,⍺           so add to the matrix 1 column and 1 row of 'a's.
               ⍪                        Identity function for a matrix.
{            }⍨                         Unary function: bind the matrix to both ⍵ and ⍺.
 ⍺≢⍵:                                   The arguments are identical,
           ∊⍺                           so flatten the matrix into the string 'aaaa'.

— Zgarb
स्रोत

2

STATA 20

di _n($a)
gl a=$a+2

There is a trailing new line to make sure that the display (di) statement works. First display the current number in $a newlines (and one additional from the default of display). Then add 2 to $a.

Uses the even numbers approach (i.e. odd numbers approach minus 1) with an extra newline every time.

— bmarks
स्रोत

2

T-SQL 117

IF OBJECT_ID('tempdb..#')IS NULL CREATE TABLE #(A INT)INSERT INTO # VALUES(1)SELECT REPLICATE('a',COUNT(*)*2-1)FROM #

Note the trailing space to ensure that the if condition is properly checked every time.

Uses the odd numbers approach. Not sure if there's a newline on select statements.

Not sure if there's a shorter way to create a table if it doesn't exist.

— bmarks
स्रोत

2

Kudos to you for an unusual language choice.

— Xynariz

2

PostScript, 35 chars

count dup 2 mul 1 add string print

Each pass "leaks" one thing on the stack, so count goes up by 1 each time. Then it justs uses the sum of odd numbers trick.

The bytes output are all \000 because that's the initial value of strings.

— Ben Jackson
स्रोत

2

Haskell, 72

putStr$let a="1";aputStr=(\n->take(n^2)$show n++cycle" ").(+1).read in a

Explanation

The apply operator $ acts as if you place surrounding parentheses around the rest of the line (there are exceptions to this, but it works in this case). aputStr is a function that takes a string with the format "abc ...", where "abc" is the square root of the length of the string, including abc. It will parse the string as an integer, and return a string starting with abc+1 and having that length squared. Because of the $ operator, this will get called recursively on "1" N times.

— Jmac
स्रोत

1

Pyth, 8 bytes

*d*2Z~Z1

This relies on the fact that N² is equal to the sum of N odd numbers. Now Pyth auto prints an new line, so I have to just print Z * 2 characters in each code where Z goes from 0 to N - 1.

Code Expansion:

*d               "Print d whose value is a space character"
  *2Z            "2 * Z times where Z's initial value is 0"
     ~Z1         "Increment the value of Z";

Try it online here

— Optimizer
स्रोत

1

Golflua, 23 bytes

X=2+(X|-2)w(S.t("&",X))

outputs a combination of & and \n characters.

Equivalent Lua code

X = 2 + (X or -2)          -- initialize X to 0 the first time, add 2 ever other time

print(string.rep("&", X))

Each time the code snippet runs it produces 2 more characters of output than the last time, starting with 1 character. The print function appends a newline, so I initialize X to 0 instead of 1.

— Seeker14491
स्रोत

0

ActionScript - 27 / 26 bytes

var n=""
trace(n);n+="11"//

or

var n=1
trace(n);n+="11"//

How it works:

var n=""
trace(n);n+="11"//var n=""
trace(n);n+="11"//

It simply comments out the first line. Note: trace adds a newline. Or maybe all the IDE's I use do that automatically.

0

GML, 27

a=''show_message(a)a+='xx'a

— Timtech
स्रोत

N ^ 2 वर्णों का निर्माण करने के लिए एक स्निपेट की N प्रतियों में शामिल हों

चुनौती

टीईसीओ, 4 बाइट्स

ब्रेनफक, 17 16 बाइट्स

ब्रेनफक, 11

अजगर 2, 22

CJam, 6 bytes

///, 21 bytes

><>, 14 bytes

Breakdown

CJam, 10 9 bytes

Python 2, 20 bytes

Java - 91 bytes

Perl, 14 bytes

Brainfuck, 10 chars

Prelude, 18 12 bytes

Java - 59 / 44 (depending on requirements)

C, 87 bytes

Dyalog APL, 20 19 bytes

STATA 20

T-SQL 117

PostScript, 35 chars

Haskell, 72

Explanation

Pyth, 8 bytes

Golflua, 23 bytes

Equivalent Lua code

ActionScript - 27 / 26 bytes

GML, 27