Ameisen auf einem natürlichen Baumstamm

23

Dies ist eine gute Herausforderung für Anfänger und ein guter Zeitkiller.

Ich sagte nur ein -natürliches- Protokoll, weil der Titel zu kurz war, das hat nichts mit Logarithmen zu tun.

Gegeben 2 Variablen:

  • Die Anzahl der Ameisen n.
  • Die Breite des Protokolls w.

Ausgabe eines Protokolls der Breite wmit nAmeisen (Beispiel gezeigt w=3, n=6)

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

Eine einzelne Ameise sieht so aus:

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

Ein paar Ameisengesetze:

  1. Ameisen dürfen sich und den Rand des Baumstamms nicht direkt berühren, sie berühren lieber Leerzeichen.
  2. Jede Ameisenreihe muss wbreit sein, mit n/wAmeisenreihen.
  3. Ameisen brauchen immer einen Stamm, die Stammbreite ist garantiert größer als 0.
  4. Ameisen brauchen auch Ameisen, die Anzahl der Ameisen ist garantiert größer als 0.
  5. Ameisen sind auch überraschend gut organisiert, sie füllen ein Protokoll von links nach rechts, von oben nach unten; als würden sie ein Buch lesen.

Ameisenproben

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

Das ist , die Person mit dem kleinsten bytecount gewinnt.

Magische Kraken-Urne
quelle
7
Verwandte .
AdmBorkBork
@AdmBorkBork Ich erinnere mich jetzt daran. Ich habe es auf halbem Weg hinter mich gebracht und die Spezifikation falsch verstanden. Vielleicht habe ich einen Teil dieser Idee unbewusst gestohlen.
Magic Octopus Urn
Dies sind Anti-Y-Logs.
Arjun
Msgstr "Jede Ameisenreihe muss breit sein". Ob w>nvor der rechten Hand mehr Platz sein sollte |oder nicht, oder liegt es an uns?
Jonathan Allan
1
-1 für Ant-xamples(ich hasse Wortspiele)
Caird Coinheringaahing

Antworten:

4

Jelly ,  44  43 Bytes

Durchgestrichen 44 ist nicht 44 bei Verwendung von  

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

Probieren Sie es online!

Wie?

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

Ich habe darüber w<nin einem Kommentar gefragt, da es etwas mehrdeutig ist.
Wenn das Protokoll ameisenweit sein muss wund nicht nur die Ameisen w, kostet es zwei Bytes:

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

Dies funktioniert genauso wie zuvor, mit der Ausnahme, dass kein einzelnes Leerzeichen vorangestellt wird, um die erste, leere Zeile zu bilden. Es wird eine ganze zusätzliche Reihe von Ameisen erstellt und alle Zeilen mit Ausnahme der nachfolgenden Leerzeile abgeschnitten.

Jonathan Allan
quelle
5

V , 70 , 68 Bytes

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

Probieren Sie es 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

Das ist mir noch nie passiert, aber ein bekannter Fehler hat mir tatsächlich Bytes erspart!

Es ist schwer zu erklären, was genau vor sich geht, aber wenn Sie versuchen, etwas nach Spalten zu duplizieren, wird V vor dem Duplizieren um eine Spalte verschoben. Welches ist, warum ursprünglich ich tat:

h<C-v>{dÀp

die nicht den doppelten Operator verwendet. Da wir jedoch bereits eine Zeile verschieben mussten, können wir dies einfach tun

hÀä<C-v>{
DJMcMayhem
quelle
Nett! Eine mögliche Nominierung für die Fehlerausbeutung: P.
Magic Octopus Urn
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";

Online Version

Jörg Hülsermann
quelle
Beim Klicken auf "Online-Version" und "Code ausführen" ist ein Fehler aufgetreten.
Kjetil S.
1
@KjetilS. ändere die PHP Version auf 7.1
Jörg Hülsermann
Ja, 7.1 ist in Ordnung.
Kjetil S.
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

Probieren Sie es online!

Mathe-Junkie
quelle
Dies ist ungültig, da die leere Zeile zwischen den Ameisen fehlt (vergleiche Beispiel w=1& n=3mit deiner Version).
FatalMerlin
@FatalMerlin Danke! Behoben :)
Math Junkie
4

05AB1E , 47 Bytes

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

Probieren Sie es online!

Erläuterung

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

SOGL , 74 71 74 Bytes

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

Erster Teil: Funktion, die einen leeren Protokollteil ausgibt

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

Der zweite Teil hat eine komprimierte Zeichenfolge "nΤ↕¬┐α┐PΝld‘, bei der es sich um die Ameise handelt. Es dekomprimiert zu \-/ OOo^/-\ . Das ist die Ameise (mit Abstand nach rechts), wird aber dann von oben nach unten nach rechts gerne genommen

159d
26ae
37bf
48cg

Es wird so gespeichert, weil die Funktion solche Zeichenfolgen anfügt (das liegt daran, dass Sie die Zeichenfolge multiplizieren können, um ihr mehrere Instanzen hinzuzufügen). Das Teil selbst: Funktion, die nach einer Zahl auf dem Stapel fragt, die angibt, wie viele Ameisen gezogen werden sollen.

                                    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

Und die Hauptfunktion:

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
quelle
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

Probieren Sie es online!

Perl 5 , 152 Bytes

Ein weiterer basiert auf der Python-Lösung:

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

Probieren Sie es online!

Kjetil S.
quelle
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",""]&

Denken, dass ich eine Mathematica-basierte Golfsprache machen muss.

Kelly Lowder
quelle
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
quelle
0

Holzkohle , 43 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Nθ

Eingabe w.

F⪪× Nθ«

Geben Sie ein n, erstellen Sie eine Zeichenfolge von nLeerzeichen und teilen Sie sie in Zeilen mit einer Länge von w(mit Ausnahme des letzten Stücks, das möglicherweise kleiner ist). Schleife über diese Zeilen.

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

Drucken Sie die Seiten des Protokollbereichs aus.

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