Dies ist ein 3x3ASCII-Puzzle:

 _____ _____ _____
|    _|     |_    |
|   (_   _   _)   |
|_   _|_( )_|_   _|
| (_) |_   _| (_) |
|  _   _) (_   _  |
|_( )_|_   _|_( )_|
|    _| (_) |_    |
|   (_       _)   |
|_____|_____|_____|

Dies ist auch ein 3x3ASCII-Puzzle:

 _____ _____ _____
|     |_   _|     |
|  _   _) (_   _  |
|_( )_|_   _|_( )_|
|    _| (_) |_    |
|   (_   _   _)   |
|_   _|_( )_|_   _|
| (_) |_   _| (_) |
|      _) (_      |
|_____|_____|_____|

Jede Zeile in einem ASCII-Puzzle (mit Ausnahme der Kantenfälle, dh der Teile, die buchstäblich an den Kanten liegen) besteht aus folgendem Muster:

   _           _           _
 _( )_ _   _ _( )_ _   _ _( )_
|_   _| (_) |_   _| (_) |_   _|
 _) (_   _   _) (_   _   _) (_
|_   _|_( )_|_   _|_( )_|_   _| ...
  (_)         (_)         (_)

Bei 2 Ganzzahlen Hund Wwo Hist die Höhe (vertikaler Betrag) und Wdie Breite (horizontaler Betrag) und Hund Wwird >1ein mögliches HxWASCII-Puzzle ausgegeben .

Beispiele

Testfall 1

Eingang: 2, 4

Ausgabe:

 _____ _____ _____ _____
|     |_   _|     |_    |
|  _   _) (_   _   _)   |
|_( )_|_   _|_( )_|_   _|
|    _| (_) |_   _| (_) |
|   (_       _) (_      |
|_____|_____|_____|_____|

Testfall 2

Eingang: 4, 4

Ausgabe:

 _____ _____ _____ _____
|     |_   _|     |_    |
|  _   _) (_   _   _)   |
|_( )_|_   _|_( )_|_   _|
|    _| (_) |_   _| (_) |
|   (_   _   _) (_   _  |
|_   _|_( )_|_   _|_( )_|
| (_) |_   _| (_) |_    |
|  _   _) (_   _   _)   |
|_( )_|_   _|_( )_|_   _|
|    _| (_) |_   _| (_) |
|   (_       _) (_      |
|_____|_____|_____|_____|

Testfall 3

Eingang: 3, 5

Ausgabe:

 _____ _____ _____ _____ _____
|     |_   _|     |_   _|     |
|  _   _) (_   _   _) (_   _  |
|_( )_|_   _|_( )_|_   _|_( )_|
|    _| (_) |_   _| (_) |_    |
|   (_   _   _) (_   _   _)   |
|_   _|_( )_|_   _|_( )_|_   _|
| (_) |_   _| (_) |_   _| (_) |
|      _) (_       _) (_      |
|_____|_____|_____|_____|_____|

Testfall 4

Eingang: 2, 2

Ausgabe:

 _____ _____
|    _|     |
|   (_   _  |
|_   _|_( )_|
| (_) |_    |
|      _)   |
|_____|_____|

Klarstellungen

• Die Höhe und Breite jedes Puzzleteils sollte nicht vergrößert oder verkleinert werden.
• Bei Hund Wgrößer als eins sind die kleinstmöglichen Abmessungen 2x2(siehe IO 4).
• Sie können ein vollständiges Programm oder eine Funktion haben.
• Die Eingabe besteht aus 2 Zeilen, wobei Hin der 1. und Win der 2. Zeile, wenn Sie eine Funktion verwenden, diese in den Parametern angegeben werden können.
• Ausgabe auf stdout (oder ähnliches).
• Dies ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes.

JavaScript (ES6) 272 277 271

Fehlerbehebung bearbeiten

Bearbeite 2 gespeicherte 6 Bytes thx @ L.Serné

Bearbeiten Sie erneut 3 Bugfixes

(w,h,z=(s,q=3,i=h)=>'|  '.slice(0,q)+s.repeat(w).substr(i%2*6+q,w*6-q-~-q)+`  |
`.slice(~q))=>eval("t=z(' _____',0,0)+z('|_   _|     ',2,--h)+z(b=' _) (_   _  ')+z(c='|_   _|_( )_',0);for(a='|_   _| (_) ';--h;)t+=z(a,2)+z(b)+z(c,0)")+z(a,2)+z(' _) (_      ')+z('|_____',1)

Weniger golfen

(w,h,
  z=(s,q=3,i=h)=>'|  '.slice(0,q)+s.repeat(w).substr(i%2*6+q,w*6-q-~-q)+'  |\n'.slice(~q),
  a='|_   _| (_) ',
  b=' _) (_   _  ',
  c='|_   _|_( )_',
  t=z(' _____',0,0)+z('|_   _|     ',2,--h)+z(b)+z(c,0)
)=>{
  for(;--h;)
    t+=z(a,2)+z(b)+z(c,0);
  return t+z(a,2)+z(' _) (_      ')+z('|_____',1)
}

Prüfung

F=
(w,h,z=(s,q=3,i=h)=>'|  '.slice(0,q)+s.repeat(w).substr(i%2*6+q,w*6-q-~-q)+`  |
`.slice(~q))=>eval("t=z(' _____',0,0)+z('|_   _|     ',2,--h)+z(b=' _) (_   _  ')+z(c='|_   _|_( )_',0);for(a='|_   _| (_) ';--h;)t+=z(a,2)+z(b)+z(c,0)")+z(a,2)+z(' _) (_      ')+z('|_____',1)

function update() {
  var w=+W.value,h=+H.value
  O.textContent=F(w,h)
}

update()

W<input id=W value=2 oninput='update()' type=number min=2>
H<input id=H value=2 oninput='update()' type=number min=2>
<pre id=O></pre>

Python, 513 Bytes

def r(m,n):
 r=3*m
 c=6*n
 l=3-(n%2)*3
 z=[1,2,3,4,5,0]
 p=zip
 return"\n".join("".join(" |_()"[[[((j%6,i%3)in[(1,0),(5,0)])*2or((j%6,i%3)in[(0,1),(0,0)])or((j%4,i%6)in[(1,1),(1,2),(3,4),(3,5)])*2or((i%6,j%12)in p(z,[10,2,10,4,8,4]))*4or((i%6,j%12)in p(z,[8,4,8,2,10,2]))*3,1,0][j in[0,c]or((j,i%6)in p([1,1,2,2],[1,2]*2)+p([c-1,c-1,c-2,c-2],[1+l,2+l]*2)or(i,j%12)in[(1,8),(1,9),(1,10),(2,8),(2,9),(2,10),(r-1,9)]or(i,j%12)==(r-1,3+6*(m%2)))*2],2*(j%6>0)or i>0][i in[0,r]]]for j in range(c+1))for i in range(r+1))

Vielleicht ist dies eher eine Übung zur Verschleierung als zum Golfen, bei der entschieden wird, zu welchem ​​Charakter jede (x,y)Koordinate gehört, anstatt jedes Muster durch eine Zeichenfolge aufzubauen. Ungolfed sieht es aus

char_codes = " |_()"
def base(row, col):
    if col % 6 in [5] and row % 3 in [0, 2]:
        return 1
    if col % 6 in [0, 4] and row % 3 in [2]:
        return 2
    return 0

def underscores(row, col):
    if col % 4 in [0] and row % 6 in [0, 1] or col % 4 in [2] and row % 6 in [3, 4]:
        return 2
    return 0

def parentheses(row, col):
    if (row % 6, col % 12) in [(0, 9), (1, 1), (2, 9), (3, 3), (4, 7), (5, 3)]:
        return 4
    if (row % 6, col % 12) in [(0, 7), (1, 3), (2, 7), (3, 1), (4, 9), (5, 1)]:
        return 3
    return 0

def value(row, col):
    return base(row, col) + underscores(row, col) + parentheses(row, col)

def new_value(last_row, last_col, row, column):
    if row in [0, last_row]:
        return 2*(column % 6 > 0) or row>0
    if column in [0, last_col]:
        return 1
    if column in [1,2] and row % 6 in [1, 2]:
        return 0
    if column in [last_col - 1, last_col - 2] and row % 6 in [[4,5],[1,2]][last_col%12>0]:
        return 0
    if row in [1, 2] and column % 12 in [8,9,10]:
        return 0
    if row == last_row - 1 and column % 12 == 9:
        return 0
    return value(row - 1, column - 1)

def puzzle(rows, cols):
    last_row = rows * 3
    last_col = cols * 6
    return "\n".join("".join(new_value(last_row, last_col, row, col) for col in range(last_col + 1)) for row in range(last_row + 1))

Die Muster selbst sehen aus wie

Wir können dies als eine Nachschlagetabelle von ganzen Zahlen mit Spalten sehen, die mod 6 und Zeilen mod 3 entnommen wurden

 012345
0     |
1
2_   _|

 0123
0_
1_
2
3  _
4  _
5

 0123456789AB
0       ( )
1 ) (
2       ( )
3 ( )
4       ) (
5 ( )

Diese Strategie, verschiedene Muster zu kombinieren, hat sich für mich hier nicht wirklich bewährt, weil das Ausdrücken ziemlich umständlich ist (obwohl ich glaube, dass ich mehr hätte Golf spielen können) und weil die Randfälle so viele Zeichen zum Reparieren benötigen. Ich mache das trotzdem, weil ich eine Minute gebraucht habe und es von Interesse sein könnte.

Mathematica, 384 Bytes

(m=#~Mod~2&;a=#~Array~Y&;s=(h="   _  ")[o="|_( )_",z="|_   _",w=" _) (_",z,p="| (_) "];l="|  _  "[o,"|    _",u="|   (_",z,p];r=h[o,q="|_    ",t=" _)   ",z,p];{X,Y}=#;a[" _____"&]<>" \n"<>Join[{a[If[#<Y,z,q]["|     "][[m@#]]&]},Table[Which[y<2,l,y<Y,s,0<1,r][[Mod[x+3y,6]]],{x,3,3X-1},{y,1,Y}],{a[If[#<2,"|     "[u],"      "[If[#<Y,w,t]]][[m[X+#]]]&],a["|_____"&]}]~Riffle~"|\n"<>"|")&

Unbenannte Funktion, die ein geordnetes Ganzzahlpaar als Argument verwendet und eine Zeichenfolge mit entsprechenden Zeilenumbrüchen zurückgibt. Mit Leerzeichen und Zeilenumbrüchen:

(m = Mod[#1, 2] &; a = Array[#1, Y] &; 
 s = (h = "   _  ")[o = "|_( )_", z = "|_   _", w = " _) (_", z, p = "| (_) "];
 l = "|  _  "[o, "|    _", u = "|   (_", z, p]; 
 r = h[o, q = "|_    ", t = " _)   ", z, p];
 {X, Y} = #1; 
 a[" _____" &] <> " \n" <>
 Riffle[
   Join[
     {a[If[#1 < Y, z, q]["|     "][[m[#1]]] &]}, 
     Table[
       Which[y < 2, l, y < Y, s, 0 < 1, r][[Mod[x + 3 y, 6]]],
       {x, 3, 3 X - 1}, {y, 1, Y}
     ],
     {a[If[#1 < 2, "|     "[u], "      "[If[#1 < Y, w, t]]][[m[X + #1]]] &],
     a["|_____" &]}
   ], "|\n"
 ] <> "|") &

Batch, 562 528 Bytes

@echo off
set t=!  !
set w=%2
set a= _) (_!_   _! (_) !        _  !_( )_!_   _ _) (_
call:d "!     !_   _" 2 " _____ _____" 4
for /l %%j in (2,1,%1)do call:t
call:d "!_____!_____" 1 "%a:~18,6%%a:~-6%" 3
exit/b
:t
set a=%a:~24%%a:~0,24%
call:d "%a:~6,6%%a:~30,6%" 1 "%a:~0,6%%a:~24,6%" 3
call:c "%a:~12,6%%a:~36,6%" 2
exit/b
:d
call:c %3 %4
:c
set s=
for /l %%i in (%w%,-2,1)do call set s=%~1%%s%%&if %%i==1 call set s=%%s:~6%%
if %2 lss 4 set s=%s%!&call set s=%%t:~0,%2%%%%s:~%2,-%2%%%%t:~-%2%%
echo %s:!=^|%

Es hat sich als widerstandsfähig gegen Golf erwiesen, da die Wiederholung zu viele Bytes kostete, um sie zu eliminieren. Ich übergebe die Zeilennummer Mod 3 manuell, weil die Berechnung zu teuer ist. Edit: Außerdem hatte ich versehentlich |jede dritte Zeile extra golfen , was falsch ist. Durch das Beheben dieses Problems habe ich 2 Bytes gespart (4 Bytes bei meiner ursprünglichen Version). Erklärung: aenthält verschiedene Puzzleteile. Die :tFunktion tauscht sie über jede Gruppe von drei Zeilen aus und extrahiert dann die erforderlichen Teilzeichenfolgen, die die :cFunktion dann paarweise wiederholt, löscht jedoch die erste Spalte, wenn wungerade ist. Die Fälle am linken und rechten Rand werden dann behandelt, bevor die Zeile ausgegeben wird. Der andere Kantenfall ist die allererste Zeile, in der die !Zeichen statt in Leerzeichen geändert werden|s (der Code vermeidet |s, weil sie in Batch schwierig zu handhaben sind).

Befunge, 263 243 Bytes

|_   _| (_)
 _) (_   _
|_   _|_( )_

|
|
|_____
 _____
>&:08p3*28p&:18p6*38pv
@#!`g82:,_v0+55+1p84:<_
\g82+g84<| `g83:+1,g\%*6-g852+*6/3+2g84\++%3+2\!:g84*4p85:!!+*`0%6\!*`
6/08g+2%^>>::::48g3/2%2*`\48g3/18g+2%!2*+38g\`*!48g3%0`*\::6/2%!48g\`\

Probieren Sie es online!

Dies funktioniert, indem Sie die x, y-Koordinaten des auszugebenden Bereichs durchlaufen und diese x , y- Werte den u , v- Koordinaten im Puzzlemuster (in den ersten drei Zeilen des Spielfelds gespeichert) zuordnen. Diese Zuordnung wird mit den folgenden Grundformeln erreicht:

u = (x+(y+2)/3*6) % 12
v = (y+2)%3 + (y==0)

Die u- Koordinate wird alle 12 Spalten wiederholt, muss jedoch alle 3 Zeilen um 6 versetzt werden. Die v- Koordinate wird alle 3 Zeilen wiederholt, aber wir addieren y==0den Wert, damit die allererste Zeile als Sonderfall gerendert werden kann. Um die Kanten zu behandeln, müssen wir jedoch einen zusätzlichen booleschen Wert e einfügen , der für verschiedene Kantenpositionen gilt und die Formeln wie folgt anpasst:

u = (x+(y+2)/3*6) % (e?6:12)
v = (y+2)%3 + (y==0) + e*4

Wenn wir uns also an einer Kante befinden, addieren wir 4 zur v- Koordinate, um das einfachere Kantenmuster in den Zeilen 5 bis 7 zu verwenden. Außerdem müssen wir jetzt die u- Koordinate um 6 statt 12 ändern, da dieses Kantenmuster Wiederholt alle 6 Spalten.

Für den e- Wert selbst ist eine ziemlich komplexe Formel erforderlich, da die Kantenpositionen einen etwas unregelmäßigen Bereich des Puzzle-Randes umfassen.

elr = (x <= 2*y/3%2 or x >= w-2*!(y/3+cols)%2) and (y%3 > 0)
etb = (y <= !(x/6%2) or y >= h-(x/6+rows)%2) and (x%6 > 0)
e   = elr or etb

Ohne zu sehr ins Detail zu gehen, besteht die grundlegende Aufteilung darin, dass elr den Kantenpositionen entlang des linken und rechten Randes entspricht , während etb Positionen entlang des oberen und unteren Randes entspricht.

JavaScript (ES6), 285 Byte

f=
(h,w,a=` _) (_|_   _| (_)    _  |_( )_|_   _      |     |_____`.match(/.{6}/g),g=(l,r,j)=>a[7].slice(0,j)+(a[l]+a[r]).repeat(w).slice(j,w*6+1-j)+`  |`.slice(-j))=>[` _____`.repeat(w),g(1,7,2),...[...Array(--h*3)].map((_,i)=>g(i%6,(i+3)%6,"312"[i%3])),g(h=h%2*6,6-h,3),g(8,8,1)].join`
`

<div oninput=o.textContent=+h.value&&+w.value?f(h.value,w.value):''><input id=h type=number min=1><input id=w type=number min=1><pre id=o>

Dies ist eine Portierung meiner Batch-Antwort, um zu sehen, ob sie mit der Antwort von @ edc65 konkurriert. Die nervig lange Saite enthält Puzzleteile. Die ersten sechs Teile stehen für zwei Reihen einer Spalte im Inneren des Puzzles. Das siebte Stück wird anstelle des vierten Stücks für die vorletzte Linie der Stichsäge verwendet. Das achte Teil wird in der zweiten Zeile der Stichsäge anstelle des fünften Teils verwendet und hat auch die doppelte Funktion als linker Rand der Stichsäge. Das neunte Stück ist die letzte Zeile des Puzzles.