C'est un bon défi pour débutant et un bon tueur de temps.

J'ai seulement dit un -natural- log parce que le titre était trop court, cela n'a rien à voir avec les logarithmes.

Étant donné 2 variables:

• Le nombre de fourmis n.
• La largeur du journal w.

Sortie d'un journal de largeur wavec des nfourmis (exemple illustré w=3, n=6)

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

Une seule fourmi ressemble à ceci:

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

Quelques lois sur les fourmis:

1. Les fourmis ne doivent pas se toucher ni directement le bord de la bûche, elles préfèrent toucher les espaces.
2. Chaque rangée de fourmis doit être wlarge, avec des n/wrangées de fourmis.
3. Les fourmis ont toujours besoin d'un journal, la largeur du journal est supérieure à 0, c'est garanti.
4. Les fourmis aussi ... eh bien, ont besoin de fourmis, le nombre de fourmis est supérieur à 0, c'est garanti.
5. Les fourmis sont aussi étonnamment bien organisées, elles rempliront un journal de gauche à droite, de haut en bas; comme s'ils lisaient un livre.

Ant-xamples

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\ |
|  ^  |
|     |

C'est le code-golf , la personne avec le plus petit nombre de victoires.

Gelée ,  44  43 octets

Barré 44 n'est pas 44 avec l'utilisation de  

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

Essayez-le en ligne!

Comment?

⁶ṁ;⁶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

J'ai posé une question w<ndans un commentaire car c'est un peu ambigu.
Si le journal doit être wlarge comme des fourmis plutôt que comme des fourmis w, cela coûte deux octets:

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

Cela fait la même chose qu'avant, sauf plutôt que d'ajouter un seul espace pour créer la première ligne vierge, il crée une rangée supplémentaire de fourmis et coupe tout sauf sa ligne vide de fin.

V , 70 , 68 octets

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

Essayez-le en ligne!

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

Cela ne m'est jamais arrivé auparavant, mais un bug connu m'a en fait sauvé des octets!

Il est un peu difficile d'expliquer exactement ce qui se passe, mais malheureusement, lorsque vous essayez de dupliquer quelque chose par colonnes, V déplacera une colonne avant de dupliquer. C'est pourquoi j'ai fait à l'origine:

h<C-v>{dÀp

qui n'utilise pas l'opérateur en double. Cependant, comme nous avions déjà besoin de déplacer une ligne, nous pouvons simplement faire

hÀä<C-v>{

PHP> = 7.1, 150 octets

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

Version en ligne

Python 2, 144 octets

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

Essayez-le en ligne!

05AB1E , 47 octets

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

Essayez-le en ligne!

Explication

"   \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 octets

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

Première partie: fonction qui génère une partie de journal vide

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

La deuxième partie a une chaîne compressée "nΤ↕¬┐α┐PΝld‘, qui est la fourmi. Il se décompresse \-/ OOo^/-\ . C'est la fourmi (avec un espacement à droite), mais prise de haut en bas puis à droite comme

159d
26ae
37bf
48cg

Il est stocké comme ça parce que la ┼fonction ajoute des chaînes comme ça (c'est parce qu'alors vous pouvez multiplier la chaîne pour y ajouter plusieurs instances). La partie elle-même: fonction qui demande un nombre sur la pile indiquant le nombre de fourmis à dessiner.

                                    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

Et la fonction principale:

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

Perl 5 , 159 octets

($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

Essayez-le en ligne!

Perl 5 , 152 octets

Un autre basé sur la solution Python:

($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|"

Essayez-le en ligne!

Mathematica 210 octets

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",""]&

Pensant que je dois créer un langage de golf basé sur Mathematica.

Python 2, 166 octets

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

Charbon de bois , 43 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｎθ

Entrée w.

Ｆ⪪× Ｎθ«

Saisissez n, puis créez une chaîne d' nespaces et divisez-la en lignes de longueur w(sauf la dernière pièce qui peut être plus petite). Faites une boucle sur ces lignes.

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

Imprimez les côtés de la section du journal.

  \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