Sierpinski Üçgen Fraktal dizgisine TeX üret


30

Meydan okuma

5 seviyeli Sierpinski Üçgen Fraktalını dizecek TeX (LaTeX) matematik denklem kodunu (aşağıda verilmiştir) veren kodu yazın. En kısa kod kazanır .

ayrıntılar

TeX (ve LaTeX gibi arkadaşlar) sofistike bir dizgi sistemidir. Matematiksel formüller için rasgele iç içe geçmiş karmaşık ifadeler yapabilir. Tesadüfen bu "iç içe geçmiş kompleks" aynı zamanda fraktalların tanımlayıcısıdır. Aşağıdaki MathJaX ile işlenir

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

by the following plain-text math-equation code consisting of nested super- and sub-scripts:

{{{{{x^x_x}^{x^x_x}_{x^x_x}}^{{x^x_x}^{x^x_x}_{x^x_x}}_{{x^x_x}^{x^x_x}_{x^x_x}}}^{{{x^x_x}^{x^x_x}_{x^x_x}}^{{x^x_x}^{x^x_x}_{x^x_x}}_{{x^x_x}^{x^x_x}_{x^x_x}}}_{{{x^x_x}^{x^x_x}_{x^x_x}}^{{x^x_x}^{x^x_x}_{x^x_x}}_{{x^x_x}^{x^x_x}_{x^x_x}}}}^{{{{x^x_x}^{x^x_x}_{x^x_x}}^{{x^x_x}^{x^x_x}_{x^x_x}}_{{x^x_x}^{x^x_x}_{x^x_x}}}^{{{x^x_x}^{x^x_x}_{x^x_x}}^{{x^x_x}^{x^x_x}_{x^x_x}}_{{x^x_x}^{x^x_x}_{x^x_x}}}_{{{x^x_x}^{x^x_x}_{x^x_x}}^{{x^x_x}^{x^x_x}_{x^x_x}}_{{x^x_x}^{x^x_x}_{x^x_x}}}}_{{{{x^x_x}^{x^x_x}_{x^x_x}}^{{x^x_x}^{x^x_x}_{x^x_x}}_{{x^x_x}^{x^x_x}_{x^x_x}}}^{{{x^x_x}^{x^x_x}_{x^x_x}}^{{x^x_x}^{x^x_x}_{x^x_x}}_{{x^x_x}^{x^x_x}_{x^x_x}}}_{{{x^x_x}^{x^x_x}_{x^x_x}}^{{x^x_x}^{x^x_x}_{x^x_x}}_{{x^x_x}^{x^x_x}_{x^x_x}}}}}

Note this is just a 5-level nesting. You do not need to generate $...$ or $$...$$ or other markup required to start/end a math equation in TeX & Co. You can preview generated TeX in many online editors, for instance: http://www.hostmath.com but you can find many others too. This question was inspired by a discussion with friends.

Update

There is a similar question but it much more general and will produce different solutions. I wanted to see really kolmogorov-complexity for a very fixed simple code that in one system (TeX) is completely explicit while in another compressed. This also address the n instead of 5 levels comment.


2
Hello; I closed your question as a duplicate because I believe that answers can be too trivially modified from the other question to answer this question. However, I like the idea and I think it looks pretty cool! :)
HyperNeutrino

2
For what it's worth, I reopened this question as I do not see the code as being trivially modifiable to translate from one to the other.
AdmBorkBork

4
That's far too quick to be accepting a solution!
Shaggy


2
When I saw this challenge, this answer came to my mind... codegolf.stackexchange.com/a/6830/67961 and... it was yours
J42161217

Yanıtlar:




14

plain TeX, 29 bytes

\def~#1x{{#1x_#1x^#1x}}~~~~~x

That outputs what others have output. But if we need the code to be compilable it would be 6 bytes more

\def~#1x{{#1x_#1x^#1x}}$~~~~~x$\bye

Explanation

~ is an active character in TeX, so we can give it a (new) definition.

\def~#1x{{#1x_#1x^#1x}} defines ~ as a macro, so that when TeX sees ~, it does the following:

  • Read everything up to the next x, and call that #1 (pattern-matching).
  • Replace the whole thing with {#1x_#1x^#1x}

For example, ~ABCx would get replaced with {ABCx_ABCx^ABCx}.

When ~~~~~x is used, #1 is ~~~~, so the whole thing gets replaced with {~~~~x_~~~~x^~~~~x}. And so on.

Once we have the long string, we can print it out to terminal with \message (and ending with a \bye so TeX stops), so \message{~~~~~x}\bye. Or typeset the resulting expression (as a mathematical formula), by surrounding it in $s : so $~~~~~x$\bye.


Sorry if there's anything wrong, first answer here.
Manuel

For a big n (rather than 5) it could be more efficient to create a macro that outputs a list of n tildes ~ rather than writing ~~~~~. Plus it would look better if the whole expression is typeset under \scriptscriptstyle.
Manuel

Nice trick… can you add an explanation, or mind if I add one? This illustrates a nice feature of pattern-matching in TeX macros, which is not a feature common to many languages (that I know of).
ShreevatsaR

I will add it, but feel free to edit.
Manuel

Oops, didn't see your comment… added a very similar explanation; feel free to reject. +1 for the nice answer!
ShreevatsaR

4

05AB1E, 17 bytes

'x5F'x¡"{x^x_x}"ý

Try it online!

Explanation

'x                  # push "x"
  5F                # 5 times do
    'x¡             # split on "x"
       "{x^x_x}"ý   # join on "{x^x_x}"

Other programs at the same byte-count include

"{x^x_x}"©4F'x¡®ý
'x5F'x"{x^x_x}".:

I feel like "{x^x_x}" can be reduced ._.
Magic Octopus Urn

4

PowerShell,  44  35 bytes

"'x'"+"-replace'x','{x^x_x}'"*5|iex

Try it online!

Uses string multiplication to repeatedly -replace xes with the sub- and super-scripts, then output.

Saved 9 bytes thanks to Joey.


"'x'"+"-replace'x','{x^x_x}'"*5|iex is a bit easier, no?
Joey

@Joey Oh, that's a clever way of doing it. Thanks!
AdmBorkBork


2

JavaScript (ES6), 45 42 37 bytes

f=n=>n>4?'x':[...'{^_}'].join(f(-~n))

Edit: Saved 3 2 bytes thanks to @Arnauld. Specifying 5 still costs me 2 bytes; this 41 40 35-byte version takes a parameter instead:

f=n=>n?[...'{^_}'].join(f(n-1)):'x'



2

Japt, 21 20 18 bytes

5Æ="\{^_}"¬qUª'xÃÌ

Test it


Explanation

5Æ             Ã

Generate an array of length 5 and map over it.

"\{^_}"¬

Split a string to an array of characters

qUª'x

Rejoin (q) to a string using the current value of U or (ª) "x".

=

Assign the result of that to U.

Ì

Get the last element in the array.


Alternatives, 18 bytes

Same as above but reducing the array after it's been created.

5o r@"\{^_}"¬qX}'x

Test it

The recursive option.

>4©'xª"\{^_}"¬qßUÄ

Test it


1

Java (OpenJDK 8) , 179 167 bayt

@Neil limanı

interface Y{static void main(String[]a){System.out.println(t.apply(1));}java.util.function.Function<Integer,String>t=N->N>0?Y.t.apply(N-1).replace("x","{x^x_x}"):"x";}

Çevrimiçi deneyin!


tBir lambda yerine gerçek bir işlev olarak yazmak için daha kısa olduğunu düşünüyorum
Roman Gräf

Tüm bir programı kullanıyorsanız, bunun yerine t.apply(1)olmalıdır t.apply(new Integer(a[0])). Peki neden sadece bir yöntem göndermiyorsunuz? String t(int n){return n>0?t(n-1).replace("x","{x^x_x}"):"x";}Eğer bu zorunluluğun gerekliliği tam bir interface Y{static void main(String[]a){System.out.print(t(new Integer(a[0])));}static String t(int n){return n>0?t(n-1).replace("x","{x^x_x}"):"x";}}
programsa

0

Wolfram Dili ( Mathematica ) - 40 karakter

Burada en iyi 3 cevabı özetliyoruz :

40 bayt:

Nest["{"<>#<>"_"<>#<>"^"<>#<>"}"&,"x",5]

41 bayt:

Nest[StringReplace["x"->"{x^x_x}"],"x",5]

44 bayt:

Last@SubstitutionSystem["x"->"{x^x_x}","x",5]

3
Başkalarına ilk birkaç gün bırakmadan, kendi mücadelenizi cevaplamanız önerilmez.
Bay Xcoder

1
İlk kod pasajınız 41 bayt gerektirmiyor mu?
Jonathan Frech

@ Mr.Xcoder, editör formu kendi cevabımı gönderme seçeneği olarak önerdiği için özür diler. Cevabımı silmeli miyim?
Vitaliy Kaurov

@VitaliyKaurov Bence yapmalısın, diğer kullanıcılar muhtemelen bunu kötü alacaklar.
Bay Xcoder


0

Pyth, 17 16 13 bayt

jF+\x*5]"{^_}

Çevrimiçi deneyin!

Python 3 çeviri:
from functools import*;print(reduce(lambda x,y:x.join(y),["x"]+5*["{^_}"]))
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.