ASCII-Puzzle

27

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.
code-golf  ascii-art  tiling 
— Bobas_Pett
quelle
Müssen die Vorsprünge der Stücke in wechselnde Richtungen sein?
— Zgarb
Soll ich zufällig ausgeben oder kann ich jedes Mal nur ein Puzzle ausgeben? Sollten alle Puzzles nach dem Zufallsprinzip einheitlich verfügbar sein?
— User48538
@Zgarb ja, ich habe im Grundmuster jede Zeile im Puzzle bearbeitet, die folgt
— Bobas_Pett
@ zyabin101 Sie müssen nur ein mögliches "ASCII-Puzzle" ausgeben, also nur 1 Ausgabe für 1 Eingabe
— Bobas_Pett
1
Der erste Versuch sieht nach einem Megabyte aus. Gute Frage.
— ElPedro

Antworten:

6

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>
Erweitern Sie das Snippet

— edc65
quelle
Sehr schön! Die Golfversion bereitet mir jedoch Probleme: Nx2 funktioniert nicht (z. B. liefert 3x2 undefinierte Werte. | ( ) | _ | (_ _) | _____ | _____ | _____ | Stück fehlt am oberen Rand. Sieht aus, als wäre etwas in der Golflation verloren gegangen. Bearbeiten: Der Fehler "Ungerade Höhe" resultiert aus Code sowohl für Golfspieler als auch für Nicht-Golfspieler.
— Bence Joful
@BenceJoful Nicht genug Test nach dem letzten Golfen. Jetzt behoben
— edc65
Sie können die Deklaration des letzten Arguments (t) und das vierte Argument (a) in die for-Schleife verschieben (und die Deklaration von b und c in die Deklaration von t wie for(t=z(' _____',0,0)+z('|_ _| ',2,--h)+z(b=' _) (_ _ ')+z(c='|_ _|_( )_',0);--h;a='|_ _| (_) ')folgt einfügen :. Dadurch werden 4 Kommas gespeichert, und Sie erhalten nur 273 Zeichen BEARBEITEN: Das Test-Snippet ist immer noch fehlerhaft ...
— Luke
@ L.Serné abgehört wie? Sie können nicht t=...in das for setzen, es schlägt fehl für h == 2. Es ist genau der Fehler, den ich heute behoben habe.
— edc65
1
np, ich habe mit deinem code rumgespielt und die ursache für das undefineddeklarieren hat sich aim letzten teil der forschleife herausgestellt. Ich habe den Code ein wenig geändert und bin dabei gelandet. Sie sollten in der Lage sein, dies mit dem eval für einen weiteren 2B-Save zu integrieren. (w,h,z=(s,q=3,i=h)=>'| '.slice(0,q)+s.repeat(w).substr(i%2*6+q,w*6-2*q+1)+' |\n'.slice(~q),a='|_ _| (_) ')=>{for(t=z(' _____',0,0)+z('|_ _| ',2,--h)+z(b=' _) (_ _ ')+z(c='|_ _|_( )_',0);--h;)t+=z(a,2)+z(b)+z(c,0);return t+z(a,2)+z(' _) (_ ')+z('|_____',1)}(276B).
— Luke
5

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.

— walpen
quelle
1
Sie können 7 Bytes sparen, indem Sie das Ganze in eine durch Semikolons getrennte Zeile setzen
— Blue
@Blue Danke Kumpel, es ist schon eine Weile her seit meinem letzten Golf und ich habe einige Tricks vergessen.
— Walpen
2

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"
 ] <> "|") &
— Greg Martin
quelle
2

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

— Neil
quelle
2

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.

— James Holderness
quelle
1

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>
Erweitern Sie das Snippet

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.

— Neil
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.