लैंग्टन की चींटी का रास्ता बनाएं ।

विवरण

एक हवाई जहाज़ पर वर्ग को या तो काले या सफेद रंग में रंगा जाता है। हम मनमाने ढंग से "चींटी" के रूप में एक वर्ग की पहचान करते हैं। चींटी अपने हर कदम पर चार कार्डिनल दिशाओं में से किसी में भी यात्रा कर सकती है। नीचे दिए गए नियमों के अनुसार चींटी चलती है:

एक सफेद वर्ग में, 90 ° दाएं मुड़ें, वर्ग के रंग को पलटें, एक इकाई को आगे बढ़ाएं

एक काले वर्ग में, 90 ° बाएं मुड़ें, वर्ग के रंग को पलटें, एक इकाई को आगे बढ़ाएं

विशेष विवरण

इनपुट: 0 और 725 (समावेशी) के बीच एक पूर्णांक एन।
आउटपुट: स्टेप एन के रूप में चींटी के "पथ" का प्रतिनिधित्व करने वाले 17 से 17 ग्रिड।

नियम

चींटी सही (3 o 'घड़ी) का सामना करना शुरू कर देती है।
चींटी ग्रिड के केंद्र में शुरू होती है।
_#@क्रमशः सफेद वर्गों, काले वर्गों और चींटी के लिए उपयोग करें ।
ग्रिड शुरू में पूरी तरह से सफेद है।
आप या तो एक पूरा कार्यक्रम बना सकते हैं या एक व्याख्या की गई भाषा पर एक फ़ंक्शन।
तार या तर्क द्वारा इनपुट।

उदाहरण

अपडेट: केस का N = 450 आउटपुट गलत था।

एन = 0

_________________
_________________
_________________
_________________
_________________
_________________
_________________
_________________
________@________
_________________
_________________
_________________
_________________
_________________
_________________
_________________
_________________

एन = 1

_________________
_________________
_________________
_________________
_________________
_________________
_________________
_________________
________#________
________@________
_________________
_________________
_________________
_________________
_________________
_________________
_________________

एन = 450

_________________
_________________
___________##____
____##______##___
___#__##___##_#__
__###_#@#__#__#__
__#_#_#_#__#_#___
_____###___#_____
_____#___________
_____#__###______
___#_#_#__#_#_#__
__#__#_#____###__
__#_##__##___#___
___##______##____
____##___________
_________________
_________________

code-golf ascii-art

— Eelvex
स्रोत

@ जोए: हाँ "पूरा कार्यक्रम या समारोह। इनपुट दलील या

— स्टडिन

@ जॉय: क्षमा करें यदि वह स्पष्ट नहीं था: आप या तो एक व्याख्या की गई भाषा पर एक कार्य कर सकते हैं या एक पूरा कार्यक्रम। आप स्टड से इनपुट ले सकते हैं या इसे एक तर्क के रूप में प्रदान कर सकते हैं।

— आठवें

@ जॉय: ध्यान दें कि चरण 1 पर चींटी पहले दाईं ओर मुड़ती है (अब उत्तर की ओर) और फिर आगे बढ़ती है। क्या आप वाकई इसे ध्यान में रख रहे हैं?

— आठवीं

@ जोए: हां, मेरा मतलब था पिछली टिप्पणी में दक्षिण था और आप सही हैं, अंतिम उदाहरण अलग-अलग एन के लिए था: - (/ उदाहरण अनुभाग को अपडेट करें)।

— 12

10

गोल्फस्क्रिप्ट - 67 वर्ण

~17.'_'*n+*\153:|;{|/()[124^.2/6+:6.1&17*)\2&(*|+:|;]@++}*|/();'@'@

हॉलवैबो का पायथन समाधान इस के समान है, इसलिए मैं केवल मुख्य अंतरों का वर्णन करूँगा।

बोर्ड को एक सरणी के बजाय एक स्ट्रिंग के रूप में संग्रहीत किया जाता है। ऐसा इसलिए है क्योंकि हम कम वर्ण वाले बोर्ड पर एक मान अपडेट कर सकते हैं (जैसा कि तार हमेशा सपाट होते हैं), और इसलिए इसे वांछित आउटपुट प्रारूप में लाना आसान है।

चींटी की स्थिति फार्मूले ((d&1)*17+1)*((d&2)-1)(यानी .1&17*)\2&(*) से बढ़ जाती है, जहां डी दिशा है। हम वेरिएबल का उपयोग करते हैं 6इसलिए हम इनिशियलाइज़ेशन को छोड़ सकते हैं।

— Nabb
स्रोत

1

Awww, अब मुझे एक GolfScript noob की तरह लग रहा है।

— आआआआआआआआआ आआआआआ आआआआआ

:6- इसलिए हीप्स्टर। मुझे आपके कोड को डीबग करने से नफरत होगी :-)

— John Dvorak

9

रूबी 1.9, 104 वर्ण

f=->z{l=[*[r=1]*17,2]*17;c=152;z.times{c+=r=(r*r>1?r/18:-r*18)*l[c]*=-1};l[c]=0;l.map{|a|putc"@_
#"[a]}}

फ़ंक्शन तर्क के माध्यम से इनपुट करें।

(146 -> 142) झुका हुआ m
(142 -> 140) के r*r>1बजाय के लिए जाँच करेंr.abs>1
(142 -> 128) उपयोग करें String#scan आउटपुट उत्पन्न करने के लिए । एक बदल दिया ==करने के लिए>
(128 -> 125) अप्रचलित चर को हटा दिया
(125 -> 122) बदलें String#tr एक सशर्त के साथ
(१२२ -> १२२) अब अपडेटेड उदाहरणों के समान आउटपुट उत्पन्न करता है
(१२२ -> १११) चींटी के मार्ग का निर्माण करते समय चरों के बजाय ints का प्रयोग करें।
(111 -> 109) कोष्ठक को बचाने के लिए कुछ अभिव्यक्तियों को फिर से व्यवस्थित करें
(109 -> 108) कोड अब एक फ़ंक्शन है
(१० Print -> १०४) हर वर्ण को अलग-अलग छापें

— Ventero
स्रोत

कार्य करने की अनुमति है।

— बारह

@ बारहवाँ: क्या फ़ंक्शन को एक स्ट्रिंग वापस करना है, या क्या इसे आउटपुट करना है?

— वेंटरो

उत्पादन।

— आठवें

6

अजगर, 123

एन = इनपुट ()
घ = x = 152
जी = (17 * [95] [10]) * 17
जबकि n: d + = g [x] / 2; g [x] ^ = 124; x + = (1, -18, -1,18) [d% 4]; n- = 1
जी [x] = 64
प्रिंट "% ग" * 306% टपल (छ)

Http://golf.shinh.org/p.rb?Langtons+.nt से मेरे पायथन समाधान का बस एक मामूली सा कार्य ।

— hallvabo
स्रोत

5

गोल्फस्क्रिप्ट 96 94 89

मेरी पसंदीदा अभद्र भाषा अर्ध-पठनीय सॉर्टा-बायटेकोड के एक और समूह के साथ वापस आ गई है।

89 संस्करण, मैं अंततः आउटपुट लूप में @ को एकीकृत करने में कामयाब रहा।

~289[0:c]*145:b;{.b>\b<)!..c++(4%:c[1 17-1-17]=b+:b;@++}@*{{(b(:b!.++'_#@@'1/=\}17*n\}17*

94 संस्करण:

~306[0:c]*152:b;{.b<\b>(!..c++(4%:c[1 18-1-18]=b+:b;\++}@*{{('_#'1/=\}17*(;n\}17*].b<\b>(;'@'\

टिप्पणी की:

               #Initialization.
~                  #Parse input.
306[0:c]*          #Make array of 306 0s, set c to 0 in the middle of that operation.
152:b;             #Set b to 152, remove 152 from the stack.
                   #b is a value for the ant's position, c for its rotation.

               #Run the algorithm.
{                  #Start of block.
    .b<\b>(        #Split the array at index b into before, after and value at b.
    !..            #Not the value and make 2 copies of it.
    c++            #Add the 2 copies to c.
    (4%:c          #Subtract 1, modulus by 4 and save the result to c.
    [1 18-1-18]=   #Define an array and take element number c.
    b+:b;          #Add b to the value, save result to b, remove result from stack.
    \++            #Reform the array.
}@*                #Switch the input to the top of the stack and run the block input times.

               #Convert array of 1s and 0s to the correct characters.
{                  #Start of block.
    {              #Start of block.
        ('_#'1/=   #Take the first array element, convert it to either '_' or '#'.
        \          #Switch the array to the top of the stack.
    }17*           #Execute block 17 times.
    (;n\           #Discard the 18th element of the line, write a lineshift.
}17*               #Execute block 17 times.

               #Insert the @.
]                  #Put everything in an array.
.b<\b>(            #Split the array at index b into before, after and value at b.
;'@'\              #Ditch the value at b, write a @ and shift it into place.

संपादित करें, मैं एक बड़ा संस्करण बना सकता हूं, यहां 59 * 59 और 10500 पुनरावृत्तियां हैं:

~59:a.*[0:c]*1741:b;{.b>\b<)!..c++(4%:c[1 a-1-59]=b+:b;@++}@*{{(b(:b!.++'_#@@'1/=\}a*n\}a*

।

___________________________________________________________
___________________________________________________________
_________________________##__##____________________________
________________________#__@_###___________________________
_______________________###__#_#_#__________________________
_______________________#####_#__##_________________________
________________________#___##_##_#________________________
_________________________###___#__##_______________________
__________________________#___##_##_#______________________
___________________________###___#__##_____________________
____________________________#___##_##_#__##________________
_____________________________###___#__##__##_______________
______________________________#___##_##__##___#____________
________________________####___###___#___#__###____________
_______________________#____#___#___##_####___#____________
______________________###____#___#_#______#_##_#___________
______________________###____#_##_____#_##__#_##___________
_______________________#____#___##_#_#_____##______________
_______________________#_#______#_#####__#___#_____________
______________________#___#####__________##_######_________
______________________###__##__#_##_#_#_#___##_#_##________
____________________##__#_#######_#___#__###____##_#_______
___________________#__#__######_##___#__#_##___#___#_______
__________________#____#_#_##_#__######_#######___#________
__________________#_####_##_#_####____##__##_#_##_#________
___________________#____####___#__#_######_##____###_______
______________________#___#_##_#_###_#__##__##___###_______
_________________________#######____#__##_##_#_____#_______
_________________####__##_##__####_##_##_##__#_____#_______
________________#____#_#___###_##_###____#_####____#_______
_______________###_______###_#_#_#####____#_#______#_______
_______________#_#___###_####_##_#___##_###_##_____#_______
_____________________##_##__####____####_#_#_#_____#_______
________________#____#__##___###__###_____###______#_______
________________##___##_###_####__#______###___##__#_______
________________##_#_####_____#___#__#_##_###_##___#_______
_______________####_##___##_####__#_#__#__#__###___#_______
_______________#_##_###__#_#_##_#_#_____#_#_____#_#________
___________________#_#__#____##_##__#_#__###_##____________
___________________##_#____#__#####_#____#____#__#_#_______
__________________#_##_#__#____##_##_#__###______###_______
________________#_#___#__#__#__#__###___##__##____#________
_______________###_#_#####_######_###_#######_#_##_________
_______________#_#_#____#####___##__#####_#####____________
_________________#__##___#______#__#_##__###_###___________
______________####___#####_#########___#_#_________________
_________##____#__#_____###_#_#___#_###__###_______________
________#__#__####_##___###_##___###_##_____##_____________
_______###____#_##_#_#####___#____#__#__##_###_____________
_______#_#####_#_#___##__##_____#____#___#__#______________
___________######_####__##_#___#__##__#_#_##_______________
_________##______#_###_##__####___#___###__________________
__________#__#_#####__#___#_##___#__#__#___________________
__________##_###_#######_____#_____#_##____________________
_________#_#__##_##______#___##____#_______________________
________#__#_####________###__##__#________________________
________#_##_###____________##__##_________________________
_________##________________________________________________
__________##_______________________________________________

— aaaaaaaaaaaa
स्रोत

5

विंडोज पॉवरशेल, 119 118

for($p,$n,$g=144,+"$args"+,1*289;$n--){$d+=$g[$p]*=-1
$p+='B0@R'[$d%4]-65}$g[$p]=0
-join'@_#'[$g]-replace'.{17}',"$&
"

— एक छोटा सा सिक्का
स्रोत

4

PHP, 350 309 307 312 174 161 166 159 151 149 147 144 143

<?$p=144;while($i=$argv[1]--){$g[$p]=$a=2-$g[$p];$d+=--$a;$p+=(1-($d&2))*(1+16*($d&1));}while($i++<288)echo$i%17?$i!=$p?$g[$i]?"#": _:"@":"\n";

Ungolfed

$p = 144; // Set initial pointer

while($i = $argv[1]--){ // Ends at -1
    $g[$p] = $a = 2 - $g[$p]; // Either returns true (2) or false(0)

    $d += --$a; // Adds 1 (2-1) or removes 1 (0-1) from the direction

    $p += (1 - ($d & 2)) * (1 + 16 * ($d & 1));
}

while($i++ < 288)
    echo $i % 17? $i != $p? $g[$i]? "#" : @_ : "@" : "\n"; // Prints the correct character

350 -> 309: सही आउटपुट दिखाने के लिए () छोरों के साथ विभिन्न संपीड़न तकनीकें भी अपडेट की गई हैं।
309 -> 307: () लूप से थोड़ी देर () लूप के लिए मुख्य रूप से परिवर्तित।
307 -> 312: argv का उपयोग करने के लिए इसे बदलना भूल गए।
312 -> 174: एक और जवाब के आधार पर पुनर्नवीनीकरण किया गया।
१४ -> १६१: अब पूरे ऐरे को डिफॉल्ट नहीं करता।
161 -> 166: अर्गव फिर से जीतता है।
166 -> 159: argv को पुनर्परिभाषित करने की आवश्यकता नहीं [1]।
159 -> 151: अब कुछ भी नहीं चूकता है, PHP स्वचालित रूप से करता है।
151 -> 149: कोष्ठक के एक सेट को हटा दिया गया, संचालन का क्रम आवश्यकता को हटा देता है।
149 -> 147: लूप () लूप के लिए अंतिम छोटा, जरूरत नहीं है।
147 -> 144:अंतिम () लूप अब थोड़ी देर () लूप है।
144 -> 143: एक चरित्र को बचाने के लिए एक अस्थायी चर का इस्तेमाल किया।

— केविन ब्राउन
स्रोत

मैं देख रहा हूँ कि आपने मेरी ग्रिड और दिशा की चाल का उपयोग किया है, और यह आपके कोड से 138 चार्ट हटा दिया है, अच्छा है!

— पैट्रिकव्ल

4

सी, 166 162

यहाँ मेरी डेल्फी-ए-सी का अनुवाद, दिखा रहा है कि कॉम्पैक्ट कैसे हो सकता है। मैंने fR0DDY (धन्यवाद साथी!) से सशर्त न्यूलाइन ट्रिक उधार ली है:

g[289]={0},a=144,d,i,N;main(){scanf("%d",&N);while(N--)g[a]=2-g[a],d+=g[a]-1,a+=(1-(d&2))*(1+d%2*16);for(g[a]=1;i<289;)printf("%s%c",i++%17?"":"\n","_@#"[g[i]]);}

इंडेंटेड, कमेंटेड संस्करण इस तरह दिखता है:

g[289]={0}, // g: The grid is initially completely white. (size=17*17=289)
a=144, // a: Ant position starts at the center of the grid (=8*17+8=144)
d, // Assume 0=d: Ant start 'd'irection faces right (=0, see below)
i,
N;
main(){
  scanf("%d",&N);
  while(N--)
    // Flip the color of the square:
    g[a]=2-g[a],
    // Turn 90° right if at an '_' space, 90° left otherwise :
    d+=g[a]-1,
    // Move one unit forward;
    //   For this, determine the step size, using the two least significant bits of d.
    //   This gives the following relation :
    //     00 = 0 =  90° = right =   1
    //     01 = 1 = 180° = down  =  17
    //     10 = 2 = 270° = left  = - 1
    //     11 = 3 =   0° = up    = -17
    //   (d and 2) gives 0 or 2, translate that to 1 or -1
    //   (d and 1) gives 0 or 1, translate that to 1 or 17
    //   Multiply the two to get an offset 1, 17, -1 or -17 :
    a+=(1-(d&2))*(1+d%2*16);
  // Place the ant and print the grid :
  for(g[a]=1;i<289;)
    printf("%s%c",i++%17?"":"\n","_@#"[g[i]]); // 0 > '_', 1='@', 2 > '#'
}

— PatrickvL
स्रोत

+1। मुझे तरकीबें पसंद हैं "_@#"[g[i]]औरa+=(1-(d&2))*(1+(16*(d&1)))

— fR0DDY

(1+d%2*16)कुछ चार्ट बचाता है।

— नब्ब

@ नब: दरअसल, जो 4 पात्रों को बचाता है, सुझाव के लिए धन्यवाद!

— पैट्रिकवेल

4

डेल्फी, 217

var g,a:PByte;i,d,Word;begin g:=AllocMem(306);a:=g+153;Read(i);for n:=1to i do begin a^:=2-a^;d:=d-1+a^;a:=a+(1-2and d)*(1+17*(1and d))end;a^:=1;for n:=1to 306do if n mod 18=0then WriteLn else Write('_@#'[1+g[n]])end.

इंडेंट एंड कमेंटेड कोड इस तरह पढ़ता है:

var
  g,a:PByte;
  i,d,n:Int32;
begin
  g:=AllocMem(306); // g: The grid is initially completely white. (size=18*17=306)
  // Assume 0=d: Ant start 'd'irection faces right (=0, see below)
  a:=g+153; // a: Ant position starts at the center of the grid (=8*18+9=153)
  Read(i);
  for n:=1to i do
  begin
    // Flip the color of the square;
    a^:=2-a^;
    // Turn 90° right if at an '_' space, 90° left otherwise;
    d:=d-1+a^;
    // Move one unit forward;
    //   For this, determine the step size, using the two least significant bits of d.
    //   This gives the following relation :
    //     00 = 0 =  90° = right =   1
    //     01 = 1 = 180° = down  =  18
    //     10 = 2 = 270° = left  = - 1
    //     11 = 3 =   0° = up    = -18
    //   (d and 2) gives 0 or 2, translate that to 1 or -1
    //   (d and 1) gives 0 or 1, translate that to 1 or 18
    //   Multiply the two to get an offset 1, 18, -1 or -18 :
    a:=a+(1-2and d)*(1+17*(1and d))
  end;
  // Place the ant and print the grid :
  a^:=1; // 0 > '_', 1='@', 2 > '#'
  for i:=1to 306do
    if i mod 18=0then // we insert & abuse column 0 for newlines only (saves a begin+end pair)
      WriteLn
    else
      Write('_@#'[1+g[i]])
end.

इनपुट:

आउटपुट:

_________________
_________________
___________##____
____##______##___
___#__##___##_#__
__###_#@#__#__#__
__#_#_#_#__#_#___
_____###___#_____
_____#___________
_____#__###______
___#_#_#__#_#_#__
__#__#_#____###__
__#_##__##___#___
___##______##____
____##___________
_________________
_________________

— PatrickvL
स्रोत

@ पैट्रिक: उदाहरण गलत था, कृपया अपडेट देखें। (और ऐसा लगता है कि आप कदम 451 :) का उत्पादन करते हैं)।

— बारहवीं

@ बारहवाँ: धन्यवाद। मैंने 4 वर्णों की लागत पर मामला 'N = 0' तय किया ... अब मैं उन्हें फिर से जीत दूंगा! ;-)

— पैट्रिकव्ल

@ बारह: पीएस: अपनी गलती को ठीक करने के लिए 3 घंटे पहले सिर्फ एक विनम्र टिप्पणी के साथ कोई +1 यह मेरी गलती हो सकती है? ;)

— पैट्रिकव्ल

— @ पैट्रिक

@ बारहवाँ: LOL, वहाँ पहुँचना ... (पहले से 238 तक नीचे)

— PatrickvL

3

C 195 वर्ण

x=144,T,p=1,i,N[289]={0},a[]={-17,1,17,-1};c(t){p=(p+t+4)%4;x+=a[p];}main(){scanf("%d",&T);while(T--)N[x]=(N[x]+1)%2,c(N[x]?1:-1);for(;i<289;i++)printf("%s%c",i%17?"":"\n",i-x?N[i]?'#':'_':'@');}

http://www.ideone.com/Dw3xW

मुझे यह 725 के लिए मिलता है।

_________________
_________________
___________##____
____##______##___
___#___##__##_#__
__###____#_#__#__
__#_#_#__#_#_#___
______###____#__@
_______###__#__#_
_____#_#____#___#
___#_#_#_##____#_
__#__#_#_#_#_###_
__#_##_#_____####
___##_#____#_####
____###___####_#_
_______#__#__##__
________####_____

— fR0DDY
स्रोत

का उपयोग p+=t+4;x+=a[p%4];करने के बजाय p=(p+t+4)%4;x+=a[p];तीन पात्रों को बचाता है।

— जॉय

3

sed, 481 chars

#n
1{s/.*/_________________/;h;H;H;H;G;G;G;G;s/^\(.\{152\}\)_/\1@/;s/$/;r/;ta;};x;:a;/;r/br;/;d/bd;/;l/bl;/;u/bu;:w;y/rdlu/dlur/;bz;:b;y/rdlu/urdl/;bz;:r;s/@\(.\{17\}\)_/#\1@/;tw;s/@\(.\{17\}\)#/#\1!/;tw;s/_\(.\{17\}\)!/@\1_/;tb;s/#\(.\{17\}\)!/!\1_/;tb;:d;s/_@/@#/;tw;s/#@/!#/;tw;s/!_/_@/;tb;s/!#/_!/;tb;:l;s/_\(.\{17\}\)@/@\1#/;tw;s/#\(.\{17\}\)@/!\1#/;tw;s/!\(.\{17\}\)_/_\1@/;tb;s/!\(.\{17\}\)#/_\1!/;tb;:u;s/@_/#@/;tw;s/@#/#!/;tw;s/_!/@_/;tb;s/#!/!_/;tb;:z;h;${s/!/@/;s/;.//p}

पहली पंक्ति को हटाकर और साथ चलाकर 478 वर्णों तक घटाया जा सकता है -n

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

seq 450 | sed -f ant.sed

आउटपुट:

_________________
_________________
___________##____
____##______##___
___#__##___##_#__
__###_#@#__#__#__
__#_#_#_#__#_#___
_____###___#_____
_____#___________
_____#__###______
___#_#_#__#_#_#__
__#__#_#____###__
__#_##__##___#___
___##______##____
____##___________
_________________
_________________

— Hasturkun
स्रोत

3

पर्ल, 110 वर्ण

$p=144;$p+=(1,-17,-1,17)[($d+=($f[$p]^=2)+1)%4]for 1..<>;$f[$p]=1;print$_%17?'':$/,qw(_ @ #)[$f[$_]]for 0..288

नंबर STDIN की पहली पंक्ति से पढ़ा जाता है। बाकी इनपुट की अनदेखी की जाती है।

थोड़ा अधिक पठनीय:

$p=144;
$p += (1,-17,-1,17)[($d+=($f[$p]^=2)+1) % 4] for 1..<>;
$f[$p]=1;
print $_%17 ? '' : $/, qw(_ @ #)[$f[$_]] for 0..288

संपादित करता

(112 → 111)$d मोड्यूलो -4 मान के साथ अपडेट करने की आवश्यकता नहीं है ।
(111 → 110) अब $dवेतन वृद्धि को रेखांकित कर सकते हैं

परिशिष्ट (109 वर्ण)

यदि आप विशेष मामले के N=0असफल होने पर खुश होते हैं, तो यह एक चरित्र छोटा हो सकता है (यह @चींटी के लिए चरित्र का उत्पादन नहीं करता है )। अन्य सभी इनपुट सही ढंग से काम करते हैं:

$p+=(1,-17,-1,17)[($d+=($f{$p+0}^=2)+1)%4]for 1..<>;$f{$p}=1;print$_%17-9?'':$/,qw(_ @ #)[$f{$_}]for-144..144

अंतर यह है कि अब हम %fइसके बजाय उपयोग करते हैं @fताकि हम नकारात्मक सूचकांकों का उपयोग कर सकें, और हम -144..144इसके बजाय से पुनरावृति करते हैं 0..288। यह इनिशियलाइज़ होने से बचाता है $p।

— Timwi
स्रोत

1

गणितज्ञ, 94 वर्ण

a@_=d=1;a@Nest[#+(d*=(a@#*=-1)I)&,9-9I,Input[]]=0;Grid@Array["@"[_,"#"][[a[#2-# I]]]&,17{1,1}]

— alephalpha
स्रोत

1

> <>, 122 बाइट्स

थोड़ा धागा परिगलन के जोखिम पर, मैंने सोचा कि उत्तर में लिखना <> एक दिलचस्प चुनौती होगी ...

1&f8r\
1-:?!\r:@@:@$:@@:@g:2*1+&+4%:&}1$-@p{:3$-5gaa*-$@+@5gaa*-+r
2}p70\~
a7+=?\:@@:@g4+5go$1+:
o053.>~1+:64*=?;a
dedc_#@

यह कार्यक्रम निष्पादन से पहले स्टैक पर उपस्थित होने के लिए गणना करने के लिए चरणों की संख्या की अपेक्षा करता है।

— सोक
स्रोत

लैंग्टन की चींटी ASCII कला।

विवरण

विशेष विवरण

नियम

उदाहरण

गोल्फस्क्रिप्ट - 67 वर्ण

रूबी 1.9, 104 वर्ण

अजगर, 123

गोल्फस्क्रिप्ट 96 94 89

विंडोज पॉवरशेल, 119 118

PHP, 350 309 307 312 174 161 166 159 151 149 147 144 143

सी, 166 162

डेल्फी, 217

sed, 481 chars

पर्ल, 110 वर्ण

थोड़ा अधिक पठनीय:

संपादित करता

परिशिष्ट (109 वर्ण)

गणितज्ञ, 94 वर्ण

> <>, 122 बाइट्स