Formigas em um tronco natural

23

Este é um bom desafio para iniciantes e um bom assassino de tempo.

Eu apenas disse um log natural porque o título era muito curto, isso não tem nada a ver com logaritmos.

Dadas 2 variáveis:

  • O número de formigas n.
  • A largura do log w.

Saída de um registo de largura wcom nformigas (Exemplo mostrado w=3, n=6)

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

Uma única formiga se parece com isso:

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

Algumas leis sobre formigas:

  1. As formigas podem não se tocar nem a borda do tronco diretamente, elas preferem tocar em espaços.
  2. Cada linha de formigas deve ser wlarga, com n/wlinhas de formigas.
  3. As formigas sempre precisam de um log, a largura do log é maior que 0, garantida.
  4. Formigas também ... bem, precisam de formigas, o número de formigas é maior que 0, garantido.
  5. As formigas também são surpreendentemente bem organizadas; elas preencherão um registro da esquerda para a direita, de cima para baixo; como se estivessem lendo um livro.

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

Isso é , a pessoa com o menor número de vitórias.

Urna de polvo mágico
fonte
7
Relacionado .
AdmBorkBork
@AdmBorkBork Lembro-me disso agora. Eu terminei a metade e interpretei mal as especificações, pode ter subconscientemente roubado parte dessa ideia.
Urna Mágica do Polvo
Estes são os logs ant-y.
Arjun #
"Cada fila de formigas deve ter largura larga". Se w>ndeveria haver espaço extra diante da mão direita |ou não, ou depende de nós?
Jonathan Allan
1
-1 para Ant-xamples(eu odeio trocadilhos)
caird coinheringaahing

Respostas:

4

Geléia ,  44  43 bytes

Riscado 44 não é 44 com o uso de  

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

Experimente online!

Quão?

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

Eu perguntei sobre w<nem um comentário, pois é um pouco ambíguo.
Se o log precisar ter wlargura de formigas em vez de apenas formigas w, custa dois bytes:

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

Isso faz o mesmo que antes, exceto que, em vez de colocar um único espaço para formar a primeira linha em branco, cria uma linha extra inteira de formigas e corta todas, exceto a linha em branco à direita.

Jonathan Allan
fonte
5

V , 70 , 68 bytes

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

Experimente online!

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

Isso nunca aconteceu comigo antes, mas um bug conhecido realmente me salvou bytes!

É meio difícil explicar exatamente o que está acontecendo, mas, infelizmente, quando você tenta duplicar algo por colunas, V move uma coluna antes de duplicar. É por isso que originalmente eu fiz:

h<C-v>{dÀp

que não usa o operador duplicado. No entanto, como já precisávamos passar uma linha, podemos simplesmente fazer

hÀä<C-v>{
DJMcMayhem
fonte
Agradável! Uma indicação potencial para a exploração de bugs: P.
Urna de polvo mágico
5

PHP> = 7.1, 150 bytes

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

Versão Online

Jörg Hülsermann
fonte
Erro ao clicar em "versão online" e "executar código".
precisa
1
@KjetilS. alterar a versão do PHP para 7.1
Jörg Hülsermann 21/04
Sim, 7.1 está ok.
precisa
5

Python 2, 144 bytes

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

Experimente Online!

viciado em matemática
fonte
Isso é inválido, pois perde a linha vazia entre as formigas (compare o exemplo w=1e n=3a sua versão).
FatalMerlin
@FatalMerlin Thanks! Corrigido :)
junkie matemática
4

05AB1E , 47 bytes

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

Experimente online!

Explicação

"   \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
fonte
4

SOGL , 74 71 74 bytes

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

Primeira parte: função que gera uma parte de log vazia

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

A segunda parte tem uma string compactada "nΤ↕¬┐α┐PΝld‘, que é a formiga. Descompacta para \-/ OOo^/-\ . Essa é a formiga (com espaçamento para a direita), mas levada de cima para baixo e para a direita como

159d
26ae
37bf
48cg

Ele é armazenado dessa maneira porque a função anexa seqüências de caracteres dessa maneira (isso é porque você pode multiplicar a sequência para adicionar várias instâncias). A parte em si: função que solicita um número na pilha, indicando quantas formigas desenhar.

                                    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

E a principal função:

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
fonte
2

Perl 5 , 159 bytes

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

Experimente online!

Perl 5 , 152 bytes

Outro baseado na solução 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|"

Experimente online!

Kjetil S.
fonte
0

Mathematica 210 Bytes

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

Pensando que preciso criar uma linguagem de golfe baseada no Mathematica.

Kelly Lowder
fonte
0

Python 2, 166 bytes

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
fonte
0

Carvão , 43 bytes

NθF⪪× Nθ«←P↓⁶M⊗⊕⊗θ→P↓⁶⸿E⪪\O/-O-/o\ ^ ³⭆ι⁺μκ

Experimente online! Link é a versão detalhada do código. Explicação:

Nθ

Entrada w.

F⪪× Nθ«

Entrada n, crie uma sequência de nespaços e divida-a em linhas de comprimento w(exceto a última peça que pode ser menor). Faça um loop sobre essas linhas.

←P↓⁶M⊗⊕⊗θ→P↓⁶⸿

Imprima os lados da seção de log.

  \O/-O-/o\ ^           Literal string
 ⪪            ³         Split into (4) pieces of length 3
E                       Map over each piece
               ⭆ι       Map over each row space
                 ⁺μκ    Appending the piece
                        Implicitly print the results on separate lines
Neil
fonte