이것은 좋은 초보자 도전과 좋은 시간 킬러입니다.

제목이 너무 짧아서-자연-로그 만 말했는데, 이것은 로그와 관련이 없습니다.

주어진 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. 개미는 놀랍게도 잘 정리되어 있으며 왼쪽에서 오른쪽, 위에서 아래로 로그를 채울 것입니다. 마치 책을 읽는 것처럼.

개미-샘플

w = 3, n = 5

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

w = 1, n = 1

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

w = 1, n = 3

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

이것은 가장 적은 바이트 수를 가진 사람 이 코드 골프 입니다.

젤리 ,  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에 의견 이 약간 모호 이후.
로그가 w개미가 아닌 개미보다 w넓은 경우 2 바이트의 비용이 듭니다.

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

이것은 첫 번째 빈 줄을 만들기 위해 단일 공백을 추가하는 것 외에는 이전과 동일하게 수행하여 개미의 전체 행을 추가로 만들고 끝 빈 줄을 제외한 모든 줄을 잘라냅니다.

V , 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

이것은 전에 나에게 일어난 적이 없지만 알려진 버그로 인해 실제로 바이트를 절약했습니다!

무슨 일이 일어나고 있는지 정확하게 설명하기는 어렵지만 불행히도 열로 무언가를 복제하려고하면 V는 복제하기 전에 한 열 위로 이동합니다. 이것이 원래 내가 한 이유입니다.

h<C-v>{dÀp

중복 연산자를 사용하지 않습니다. 그러나 이미 한 줄 위로 이동해야했기 때문에 간단히

hÀä<C-v>{

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";

온라인 버전

파이썬 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

온라인으로 사용해보십시오!

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

SOGL , 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‘개미 인 압축 문자열 이 있습니다. 압축을 풉니 다 \-/ 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

펄 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|"

온라인으로 사용해보십시오!

매스 매 티카 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",""]&

Mathematica 기반의 골프 언어를 만들어야한다고 생각합니다.

파이썬 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\\',' ^ ','   ']])

숯 , 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