एक प्राकृतिक लॉग पर चींटियों

23

यह एक अच्छी शुरुआत चुनौती है और एक अच्छा समय हत्यारा है।

मैंने केवल एक अप्राकृतिक-लॉग कहा है क्योंकि शीर्षक बहुत छोटा था, इसका लॉगरिदम से कोई लेना-देना नहीं है।

2 चर दिए गए:

  • चींटियों की संख्या n।
  • लॉग की चौड़ाई w।

आउटपुट चौड़ाई का एक लॉग wके साथ nचींटियों (उदाहरण से पता चला w=3, n=6)

|             |
| \O/ \O/ \O/ |
| -O- -O- -O- |
| /o\ /o\ /o\ |
|  ^   ^   ^  |
|             |
| \O/ \O/ \O/ |
| -O- -O- -O- |
| /o\ /o\ /o\ |
|  ^   ^   ^  |
|             |

एक एकल चींटी इस तरह दिखती है:

\O/ # Upper-case O
-O- # Upper-case O
/o\ # Lower-case o
 ^

कुछ चींटी कानून:

  1. चींटियां न तो एक-दूसरे को छू सकती हैं और न ही लॉग के किनारे को सीधे स्पर्श करती हैं।
  2. चींटियों की प्रत्येक पंक्ति wविस्तृत होनी चाहिए , n/wचींटियों की पंक्तियों के साथ ।
  3. चींटियों को हमेशा लॉग की आवश्यकता होती है, लॉग की चौड़ाई 0 से अधिक है, गारंटी है।
  4. चींटियों ... अच्छी तरह से, चींटियों की जरूरत है, चींटियों की संख्या 0 से अधिक है, गारंटी।
  5. चींटियों को आश्चर्यजनक रूप से अच्छी तरह से व्यवस्थित किया जाता है, वे बाएं से दाएं, ऊपर से नीचे तक एक लॉग भरेंगे; मानो वे कोई किताब पढ़ रहे हों।

चींटी-xamples

डब्ल्यू = ३, एन = ५

|             |
| \O/ \O/ \O/ |
| -O- -O- -O- |
| /o\ /o\ /o\ |
|  ^   ^   ^  |
|             |
| \O/ \O/     |
| -O- -O-     |
| /o\ /o\     |
|  ^   ^      |
|             |

डब्ल्यू = १, एन = १

|     |
| \O/ |
| -O- |
| /o\ |
|  ^  |
|     |

डब्ल्यू = १, एन = ३

|     |
| \O/ |
| -O- |
| /o\ |
|  ^  |
|     |
| \O/ |
| -O- |
| /o\ |
|  ^  |
|     |
| \O/ |
| -O- |
| /o\ |
|  ^  |
|     |

यह कोड-गोल्फ है , सबसे छोटा बाइटकाउंट वाला व्यक्ति जीतता है।

code-golf  ascii-art  code-golf  code-golf  kolmogorov-complexity  code-golf  string  unicode  code-golf  number  sequence  primes  palindrome  code-golf  game  decision-problem  code-golf  math  geometry  code-golf  graphical-output  interactive  code-golf  set-partitions  code-golf  number  arithmetic  restricted-source  code-golf  decision-problem  python  recursion  code-golf  ascii-art  code-golf  source-layout  code-golf  function  recursion  functional-programming  code-golf  game  combinatorics  permutations  code-golf  string  file-system  code-golf  string  hashing  code-golf  stack-exchange-api  code-golf  string  code-golf  math  number  arithmetic  polyglot 
— जादू ऑक्टोपस Urn
स्रोत
7
— AdmBorkBork
@AdmBorkBork मुझे याद है कि अब। मैं इसके साथ आधा हो गया और कल्पना को गलत कर दिया, हो सकता है कि अवचेतन रूप से उस विचार का हिस्सा चुरा लिया हो।
— मैजिक ऑक्टोपस Urn
ये एंटी-वाई-लॉग हैं।
— अर्जुन
"चींटियों की प्रत्येक पंक्ति चौड़ी होनी चाहिए"। यदि w>nदाहिने हाथ से पहले अतिरिक्त स्थान होना चाहिए |या नहीं, या यह हमारे ऊपर है?
— जोनाथन एलन
1
-1 के लिए Ant-xamples(मुझे
— सज़ा से

जवाबों:

4

जेली ,  44  43 बाइट्स

44 का उपयोग करने के साथ क्रॉस आउट 44 नहीं है  

⁶ṁ;⁶jЀ“\-/“OOo^ ”;UṖz⁶¤Y
sÇ€⁶;YỴz⁶Zj@€⁾||Y

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

कैसे?

⁶ṁ;⁶jЀ“\-/“OOo^ ”;UṖz⁶¤Y - Link 1, make a row of ants: list x (could be integer = length)
⁶                         - literal ' '
 ṁ                        - mould like x (makes a list of that many spaces)
  ;⁶                      - concatenate one more space
                       ¤  - nilad followed by link(s) as a nilad
       “\-/“OOo^ ”        -   literal      ["\-/","OOo^ "] ("..." a list of chars really)
                   U      -   reverse each [" ^oOO","/-\"]
                  ;       -   concatenate  ["\-/","OOo^ "," ^oOO","/-\"]
                    Ṗ     -   pop          ["\-/","OOo^ "," ^oOO"]
                      ⁶   -   literal ' '
                     z    -   transpose & fill ["\O/","-O-","/o\"," ^ ","   "]
    jЀ                   - join left mapped over right
                          -   (join the spaces with each of the ant parts in turn)
                        Y - join with newlines

sÇ€⁶;YỴz⁶Zj@€⁾||Y - Main link: n, w
s                 - split n into chunks of length w (implicitly makes a range of length n)
 Ç€               - call the last link (1) as a monad for €ach
   ⁶;             - a space concatenated with that
     Y            - join with newlines
      Ỵ           - split at newlines (both the ones we just joined with AND the others!)
       z⁶         - transpose & fill with space characters (making the shorter rows,
                  -   including the single space as long as the longest one)
         Z        - transpose it back the right way
             ⁾||  - literal ['|','|']
          j@€     - join with reverse arguments for €ach (put each row between pipes)
                Y - join back up with newlines
                  - implicit print

मैंने एक टिप्पणी के बारे w<nमें पूछा है क्योंकि यह थोड़ा अस्पष्ट है। यदि लॉग को चींटियों के बजाय चौड़ी होने की जरूरत है , तो इसकी कीमत दो बाइट्स होती है:
ww

⁶ṁ;⁶jЀ“\-/“OOo^ ”;UṖz⁶¤Y
+RsÇ€YỴz⁶Zj@€⁾||ṫ5Y

यह पहले को खाली करने के लिए एक ही स्थान को तैयार करने के बजाय पहले की तरह ही करता है, रिक्त लाइन यह चींटियों की एक पूरी अतिरिक्त पंक्ति बनाता है और सभी को काट देता है लेकिन इसकी पीछे की खाली लाइन।

— जोनाथन एलन
स्रोत
5

वी , 70 , 68 बाइट्स

i \O/ 
 -O- 
 /o\ 
  ^  Àä{ò@bf }C GïpòÇÓ/d
HÄÒ çÞ/ÙÒ 
ëI|yê$p

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

00000000: 6920 5c4f 2f20 0a20 2d4f 2d20 0a20 2f6f  i \O/ . -O- . /o
00000010: 5c20 0a20 205e 2020 1bc0 e416 7bf2 4062  \ .  ^  ....{.@b
00000020: 6620 167d 4320 1b47 ef70 f2c7 d32f 640a  f .}C .G.p.../d.
00000030: 48c4 d220 e7de 2fd9 d220 0a16 eb49 7c1b  H.. ../.. ...I|.
00000040: 79ea 2470                                y.$p

यह मेरे साथ पहले कभी नहीं हुआ है, लेकिन एक ज्ञात बग ने वास्तव में मुझे बाइट्स बचा लिया है!

यह थोड़े कठिन है कि वास्तव में क्या चल रहा है, यह समझाना मुश्किल है, लेकिन दुर्भाग्य से जब आप कॉलम द्वारा कुछ नकल करने की कोशिश करते हैं, तो वी डुप्लिकेट करने से पहले एक कॉलम को आगे बढ़ा देगा। यही कारण है कि मूल रूप से मैंने किया था:

h<C-v>{dÀp

जो डुप्लिकेट ऑपरेटर का उपयोग नहीं करता है। हालाँकि, क्योंकि हमें पहले से ही एक लाइन को आगे बढ़ाने की जरूरत थी, हम बस कर सकते हैं

hÀä<C-v>{
— DJMcMayhem
स्रोत
अच्छा! बग शोषण के लिए एक संभावित नामांकन: पी।
— मैजिक ऑक्टोपस Urn
5

PHP> = 7.1, 150 बाइट्स

for([,$w,$n]=$argv;$i<ceil($n/$w)*5+1;)echo str_pad("| ".str_repeat(["","\O/ ","-O- ","/o\ "," ^  "][$i%5],$n<$w*ceil($i++/5)?$n%$w:$w),$w*4+2)."|\n";

ऑनलाइन संस्करण

— जार्ग हुल्सरमैन
स्रोत
"ऑनलाइन संस्करण" और "कोड निष्पादित करें" पर क्लिक करने पर मुझे त्रुटि मिली।
— Kjetil एस।
1
@KjetilS। PHP संस्करण को 7.1 में बदलें
— Jörg Hülsermann
हाँ, 7.1 ठीक है।
— केजेटिल एस।
5

पायथन 2, 144 बाइट्स

n,w=input()
s=' ';k='|';a=k+s*w*4+s+k;print a
while n>0:
 for i in['\\O/','-O-','/o\\',' ^ ']:print k+s+(i+s)*min(w,n)+s*4*(w-n)+k
 n-=w;print a

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

— गणित के दीवाने
स्रोत
यह अमान्य है क्योंकि यह चींटियों (उदाहरण के लिए w=1और n=3आपके संस्करण से तुलना ) के बीच की खाली लाइन को याद करता है ।
— फटलमर्लिन
@FatalMerlin धन्यवाद! फिक्स्ड :)
— गणित जंकी
4

05AB1E , 47 बाइट्स

"   \O/-O-/o\ ^ "5äðìI.D)IôvyøJ'|ì})˜¬¸«.B„ |«»

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

व्याख्या

"   \O/-O-/o\ ^ "                                # push the ant-string
                 5ä                              # split into 5 parts
                   ðì                            # prepend a space to each
                     I.D                         # copy input-1 number of times
                        )                        # wrap in a list
                         Iô                      # split into parts each the size of input-2
                           v                     # for each row of ants
                            yø                   # zip, so body parts are on the same row
                              J'|ì               # join to string and prepend a pipe to each
                                  }              # end loop
                                   )˜            # wrap in a flattened list
                                     ¬¸«         # append a copy of the first row (spaces)
                                        .B       # pad rows to equal length with spaces
                                          „ |«   # append " |" to each row
                                              »  # merge on newlines
— Emigna
स्रोत
4

एसओजीएल , 74 71 74 बाइट्स

 |pe4*I@*o |o→L:"╔O¦‘2n;"nΤ↕¬┐α┐PΝld‘*┼eG-’⁵@**┼ |4*┼OL→ALbe÷:?{eA}}be%:?A

पहला भाग: फ़ंक्शन जो एक खाली लॉग भाग को आउटपुट करता है

             →L  define function L
 |p              output in a newline "|"
   e4*           multiply width by 4
      I          increace that
       @*        get that many spaces
         o       append [to current line] that
           |o    append "|"

दूसरे भाग में एक संकुचित स्ट्रिंग है "nΤ↕¬┐α┐PΝld‘, जो चींटी है। यह करने के लिए decompresses \-/ OOo^/-\ । वह चींटी है (दाईं ओर गोलाई के साथ), लेकिन ऊपर-से-नीचे ले जाने के बाद दाईं ओर की तरह

159d
26ae
37bf
48cg

यह इस तरह संग्रहीत होता है क्योंकि ┼फ़ंक्शन स्ट्रिंग को इस तरह से जोड़ देता है (ऐसा इसलिए है क्योंकि आप इसे कई उदाहरण जोड़ने के लिए स्ट्रिंग को गुणा कर सकते हैं)। खुद हिस्सा: समारोह जो ढेर पर एक संख्या के लिए पूछता है कि कितने चींटियों को आकर्षित करना है।

                                    Example input: width 3, on stack 2
:                                   duplicate the input                             [2,2]
 "╔O¦‘                              push "| | | | "                                 [2,2,"| | | | "]
      2n                            split into chunks of two                        [2,2,["| ","| ","| ","| "]]
        ;                           put one of the input copies ontop of the stack  [2,["| ","| ","| ","| "], 2]
         "...‘*                     multiply that many ants                         [2,["| ","| ","| ","| "], "\\-/ OOo^/-\\     \\-/ OOo^/-\\     "]
               ┼                    add horizontally the ants                       ["| \O/ \O/ \O/ ",
                                                                                     "| -O- -O- -O- ",
                                                                                     "| /o\ /o\ /o\ ",
                                                                                     "|  ^   ^   ^  "]
                e                   get the width                                   [["| \\O/ \\O/ \\O/ ", "| -O- -O- -O- ", "| /o\\ /o\\ /o\\ ", "|  ^   ^   ^  "], 3]
                 G-                 subtract input from it                          [["| \\O/ \\O/ \\O/ ", "| -O- -O- -O- ", "| /o\\ /o\\ /o\\ ", "|  ^   ^   ^  "], 1]
                   ’⁵@*             push 16 spaces                                  [["| \\O/ \\O/ \\O/ ", "| -O- -O- -O- ", "| /o\\ /o\\ /o\\ ", "|  ^   ^   ^  "], 1, "                "]
                       *            multiply [the 16 spaces and empty place count]  [["| \\O/ \\O/ \\O/ ", "| -O- -O- -O- ", "| /o\\ /o\\ /o\\ ", "|  ^   ^   ^  "], "                "]
                        ┼           add that horizontally                           [["| \\O/ \\O/ \\O/     ", "| -O- -O- -O-     ", "| /o\\ /o\\ /o\\     ", "|  ^   ^   ^      "]]
                          |4*┼      add 4 vertical bars to the array                [["| \\O/ \\O/ \\O/     |", "| -O- -O- -O-     |", "| /o\\ /o\\ /o\\     |", "|  ^   ^   ^      |"]]
                              O     output the array                                []
                               L    call the empty line function                    []
                                →A  define as A

और मुख्य कार्य:

L                  call the empty line drawing function
 be÷               push floor(b/e) (the amount of full lines)
    :?{eA}}        that many times call A with the full width on the stack
           be%     push b%e (the leftovers)
              :?   if truthy (aka !=0)
                A   call A with for the leftovers
— dzaima
स्रोत
2

पर्ल 5 , 159 बाइट्स

($w,$n)=@ARGV;
print
$_%$w?"":"| ",
['   \O/-O-/o\\ ^ '=~/.../g]->[($_<5*$w*int$n/$w||$_%$w<$n%$w?$_/$w:0)%5],
($_+1)%$w?" ":" |\n"
for 0..$w*(6+5*int(($n-1)/$w))-1

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

पर्ल 5 , 152 बाइट्स

पायथन समाधान के आधार पर एक और एक: 

($w,$n)=@ARGV;
$b=' 'x($w*4+1);$j=$a="|\n|";
map$j.=' '."$_ "x($w<$n?$w:$n).'    'x($w-$n).$a,'\\O/','-O-','/o\\',' ^ 'and$n-=$w
while$n>0;
print"|$b$j$b|"

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

— केजेटिल एस।
स्रोत
0

गणितज्ञ 210 बाइट्स

StringRiffle[If[#2==c||#2==1,"|",If[r-#1<6&&#2>2+4 (a+w-h w),Table[" ",5,4],Characters@"    \\O/ -O- /o\\  ^  "~Partition~4][[1+Mod[#1-1,5],1+Mod[#2+1,4]]]]&~Array~{r=5(h=⌈(a=#)/(w=#2)⌉)+1,c=4w+3},"\n",""]&

यह सोचकर कि मुझे एक गणितज्ञ आधारित गोल्फ भाषा बनाने की आवश्यकता है।

— केली लोडर
स्रोत
0

पायथन 2, 166 बाइट्स

w,n=input()
print'\n'.join(['|'+' '*w*4+' |']+[' '.join(['|']+[p]*r+['   ']*(w-r)+['|'])for r in[w]*(n/w)+[[],[n%w]][n%w>0] for p in['\O/','-O-','/o\\',' ^ ','   ']])
— TFeld
स्रोत
0

चारकोल , 43 बाइट्स

ＮθＦ⪪× Ｎθ«←Ｐ↓⁶Ｍ⊗⊕⊗θ→Ｐ↓⁶⸿Ｅ⪪\O/-O-/o\ ^ ³⭆ι⁺μκ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｎθ

इनपुट w।

Ｆ⪪× Ｎθ«

इनपुट n, फिर nरिक्त स्थान की एक स्ट्रिंग बनाएं और इसे लंबाई की पंक्तियों में विभाजित करें w(अंतिम टुकड़े को छोड़कर जो छोटा हो सकता है)। उन पंक्तियों पर लूप करें।

←Ｐ↓⁶Ｍ⊗⊕⊗θ→Ｐ↓⁶⸿

लॉग सेक्शन के साइड प्रिंट करें।

  \O/-O-/o\ ^           Literal string
 ⪪            ³         Split into (4) pieces of length 3
Ｅ                       Map over each piece
               ⭆ι       Map over each row space
                 ⁺μκ    Appending the piece
                        Implicitly print the results on separate lines
— नील
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.