To jest 3x3układanka ASCII:

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

Jest to również 3x3układanka ASCII:

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

Każda linia układanki ASCII (z wyjątkiem skrzynek na krawędzie, tj. Elementów dosłownie na krawędziach) składa się z następującego wzoru:

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

Biorąc pod uwagę 2 liczby całkowite Hi Wgdzie Hjest wysokość (wysokość w pionie) i Wszerokość (kwota w poziomie) Hi Wsą >1wyprowadzane możliwe HxWukładanki ASCII.

Przykłady

Przypadek testowy 1

Wkład: 2, 4

Wydajność:

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

Przypadek testowy 2

Wkład: 4, 4

Wydajność:

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

Przypadek testowy 3

Wkład: 3, 5

Wydajność:

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

Przypadek testowy 4

Wkład: 2, 2

Wydajność:

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

Wyjaśnienia

• Wysokość i szerokość każdego elementu układanki nie powinny być powiększane ani zmniejszane.
• Z Hi Wbędąc większym niż jeden, najmniejsze możliwe wymiary to 2x2(patrz IO 4).
• Możesz mieć pełny program lub funkcję.
• Dane wejściowe będą składały się z 2 linii z H1 i W2, jeśli używasz funkcji, możesz mieć je w parametrach.
• Wyjście na standardowe wyjście (lub coś podobnego).
• To jest golf golfowy, więc wygrywa najkrótsza odpowiedź w bajtach.

JavaScript (ES6) 272 277 271

Edytuj poprawkę błędu

Edytuj 2 zapisane 6 bajtów thx @ L.Serné

Edytuj ponownie 3 poprawki błędów

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

Mniej golfa

(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)
}

Test

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 bajtów

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

Być może jest to raczej ćwiczenie polegające na zaciemnianiu niż na grze w golfa. Działa to, decydując, do której postaci (x,y)dąży każda ze współrzędnych, zamiast budować każdy wzór po łańcuchu. Wygląda na to, że nie ma golfa

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

Same wzory wyglądają

widzimy to jako tablicę przeglądową z liczb całkowitych z kolumnami pobranymi mod 6 i wierszami mod 3

 012345
0     |
1
2_   _|

 0123
0_
1_
2
3  _
4  _
5

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

Ta strategia łączenia różnych wzorów tak naprawdę mi się nie przydała, ponieważ ich wyrażanie jest dość kłopotliwe (choć myślę, że mógłbym więcej zagrać w golfa) i ponieważ przypadki krawędzi wymagają naprawy tak wielu postaci. Podnoszę to niezależnie, ponieważ zajęło mi to minutę i może być interesujące.

Mathematica, 384 bajty

(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"<>"|")&

Nienazwana funkcja przyjmująca za argument argument uporządkowaną parę liczb całkowitych i zwracająca ciąg zawierający odpowiednie znaki nowej linii. Z dodanymi spacjami i znakami nowej linii:

(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"
 ] <> "|") &

Partia, 562 528 bajtów

@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:!=^|%

Okazało się, że jest odporny na grę w golfa, ponieważ powtórzenie zwykle kosztowało zbyt wiele bajtów, aby go wyeliminować, na przykład ręcznie przekazuję numer linii mod 3, ponieważ jest zbyt drogi do obliczenia. Edycja: Co więcej, co nieumyślnie grałem w dodatkowe |linie co trzecią linię, co jest nieprawidłowe. Naprawienie tego faktycznie zaoszczędziło mi 2 bajty (4 bajty w mojej oryginalnej wersji). Objaśnienie: azawiera różne kawałki układanki. W :tswapy funkcyjne ich przez każdego zestawu trzech rzędach, a następnie wyodrębnia żądane podciągi których :cfunkcja powtarza się parami, a usuwanie pierwszej kolumny, jeśli wjest nieparzysta. Przypadki lewej i prawej krawędzi są następnie obsługiwane przed wyjściem wiersza. Drugi przypadek krawędzi to pierwszy rząd, w którym !s są zamieniane na spacje zamiast|s (kod unika |s, ponieważ jest trudny w obsłudze we wsadzie).

Befunge, 263 243 bajtów

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

|
|
|_____
 _____
>&: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\`\

Wypróbuj online!

Działa to poprzez iterację współrzędnych x, y obszaru, który chcemy wygenerować, i odwzorowanie tych wartości x , y na współrzędne u , v we wzorze układanki (zapisanym w pierwszych trzech liniach pola gry). To odwzorowanie osiąga się za pomocą następujących podstawowych formuł:

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

U koordynować powtarza się co 12 kolumn, ale również musi być przesunięty o 6 co 3 rzędach. V współrzędnych powtarza się co 3 wiersze, ale dodać y==0do wartości więc pierwszy rząd może być przedstawiany jako szczególny przypadek. Jednak aby obsłużyć krawędzie, musimy wprowadzić dodatkową wartość logiczną e , która jest prawdziwa dla różnych lokalizacji krawędzi i która dostosowuje formuły w następujący sposób:

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

Tak więc, jeśli jesteśmy na krawędzi, dodajemy 4 do współrzędnej v , aby zastosować prostszy wzór krawędzi na liniach od 5 do 7. A także musimy teraz zmodyfikować współrzędną u o 6 zamiast 12, ponieważ ten wzór krawędzi powtarza się co 6 kolumn.

Jeśli chodzi o samą wartość e , wymaga to dość złożonej formuły, ponieważ lokalizacje krawędzi obejmują nieco nieregularny obszar granicy puzzli.

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

Bez wchodzenia w zbyt wiele szczegółów, podstawowym podziałem jest to, że elr dopasowuje lokalizacje krawędzi wzdłuż lewej i prawej krawędzi, podczas gdy etb dopasowuje lokalizacje wzdłuż górnej i dolnej granicy.

JavaScript (ES6), 285 bajtów

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>

To jest część mojej odpowiedzi wsadowej, aby zobaczyć, czy konkuruje z odpowiedzią @ edc65. Irytująco długi sznurek zawiera elementy układanki. Pierwsze sześć elementów reprezentuje dwa rzędy jednej kolumny wnętrza układanki. Siódmy kawałek jest używany do przedostatniej linii układanki, zamiast czwartego elementu. Ósmy kawałek jest używany w drugiej linii wyrzynarki, zamiast piątego elementu, a także pełni podwójną funkcję jako lewa krawędź wyrzynarki. Dziewiąty element to ostatnia linia układanki.