Puzzle ASCII

27

Ceci est un 3x3puzzle ASCII:

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

C'est aussi un 3x3puzzle ASCII:

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

Chaque ligne d'un puzzle ASCII (à l'exclusion des cas de bord c'est-à-dire les pièces littéralement sur les bords) se compose du motif suivant:

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

Étant donné 2 entiers Het WHest la hauteur (montant vertical) et West la largeur (montant horizontal) et Het Wsont >1sortis un HxWpuzzle possible ASCII.

Exemples

Cas de test 1

Contribution: 2, 4

Sortie:

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

Cas de test 2

Contribution: 4, 4

Sortie:

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

Cas de test 3

Contribution: 3, 5

Sortie:

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

Cas de test 4

Contribution: 2, 2

Sortie:

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

Clarifications

  • La hauteur et la largeur de chaque pièce du puzzle ne doivent pas être augmentées ou réduites.
  • Avec Het Wétant supérieur à un, les plus petites dimensions possibles sont 2x2(voir IO 4).
  • Vous pouvez avoir un programme complet ou une fonction.
  • L'entrée sera de 2 lignes avec Hau 1er et Wau 2ème si vous utilisez une fonction vous pouvez les avoir dans les paramètres.
  • Sortie vers stdout (ou quelque chose de similaire).
  • C'est le code-golf, donc la réponse la plus courte en octets gagne.
Bobas_Pett
la source
Les onglets des pièces doivent-ils être dans des directions alternées?
Zgarb
Dois-je produire au hasard ou puis-je générer un seul puzzle à chaque fois? Si au hasard, tous les puzzles devraient-ils être disponibles de manière uniforme?
user48538
@Zgarb oui, j'ai édité dans le motif de base chaque ligne du puzzle qui suit
Bobas_Pett
@ zyabin101 vous avez juste besoin de sortir un possible "puzzle ASCII" donc seulement 1 sortie pour 1 entrée
Bobas_Pett
1
La première tentative donne l'impression qu'elle se terminera à environ un mégaoctet. Bonne question.
ElPedro

Réponses:

6

JavaScript (ES6) 272 277 271

Modifier la correction de bogue

Modifier 2 enregistrés 6 octets thx @ L.Serné

Modifier à nouveau 3 correction de bogue

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

Moins golfé

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

Tester

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>

edc65
la source
Très agréable! La version golfée me pose des problèmes, cependant: Nx2 ne fonctionne pas (par exemple, 3x2 donne undefined | | ( ) | _ | | (_ _) | | _____ | _____ | _____ | et soumettre une hauteur étrange donne en haut à droite pièce manquant de sa bordure supérieure. On dirait que quelque chose s'est perdu dans la golf-lation. Edit: le bug "hauteur impaire" résulte du code
golfé
@BenceJoful Pas assez de tests après le dernier golf. Maintenant corrigé
edc65
Vous pouvez déplacer la déclaration du dernier argument (t) et le quatrième argument (a) vers la boucle for (et déplacer la déclaration de b et c à l'intérieur de la déclaration de t comme ceci for(t=z(' _____',0,0)+z('|_ _| ',2,--h)+z(b=' _) (_ _ ')+z(c='|_ _|_( )_',0);--h;a='|_ _| (_) '):. Cela enregistre 4 virgules, donc vous vous retrouvez avec seulement 273 caractères EDIT: L'extrait de test est toujours buggé ...
Luke
@ L.Serné bugé comment? Vous ne pouvez pas mettre t=...à l'intérieur du for, il échoue pour h == 2. C'est exactement le bug que j'ai corrigé aujourd'hui.
edc65
1
np, j'ai joué avec votre code, et la cause de la undefineds'est avérée être déclarée adans la dernière partie de la forboucle. J'ai changé un peu le code et je me suis retrouvé avec ça. Vous devriez pouvoir l'intégrer à l'eval pour une autre sauvegarde 2B. (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)}(276 B).
Luke
5

Python, 513 octets

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

Peut-être plus un exercice d'obscurcissement que de golf, celui-ci fonctionne en décidant à quel caractère chaque (x,y)coordonnée va plutôt que de construire chaque motif par chaîne. Ungolfed il ressemble

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

Les motifs eux-mêmes ressemblent

nous pouvons voir cela comme une table de recherche à partir d'entiers avec des colonnes prises mod 6 et des lignes mod 3

 012345
0     |
1
2_   _|

 0123
0_
1_
2
3  _
4  _
5

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

Cette stratégie de combinaison de différents modèles n'a pas vraiment fonctionné pour moi ici car les exprimer est assez lourd (bien que je pense que j'aurais pu jouer plus) et parce que les cas de bord prennent tellement de caractères à corriger. Je mets ça de côté, car cela m'a pris une minute et ça pourrait être intéressant.

walpen
la source
1
Vous pouvez économiser 7 octets en mettant le tout sur 1 ligne séparée par des points
Blue
@Blue Merci mon pote, ça fait un moment depuis mon dernier golf et j'ai oublié quelques trucs.
walpen
2

Mathematica, 384 octets

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

Fonction sans nom prenant comme argument une paire ordonnée d'entiers et renvoyant une chaîne contenant des sauts de ligne appropriés. Avec des espaces et des nouvelles lignes ajoutés:

(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
la source
2

Lot, 562 528 octets

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

Prouvé résistant au golf, car la répétition a tendance à coûter trop d'octets à éliminer, par exemple, je passe manuellement le numéro de ligne mod 3 car il est trop cher à calculer. Edit: De plus, j'avais par inadvertance joué au golf supplémentaire |toutes les trois lignes, ce qui est incorrect. La résolution de ce problème m'a en fait économisé 2 octets (4 octets sur ma version d'origine). Explication: acontient divers morceaux de puzzle. La :tfonction les échange sur chaque ensemble de trois lignes, puis extrait les sous-chaînes requises que la :cfonction répète ensuite par paires, mais en supprimant la première colonne si elle west impaire. Les cas des bords gauche et droit sont ensuite traités avant la sortie de la ligne. L'autre cas de bord est la toute première ligne dans laquelle les !s sont remplacés par des espaces au lieu de|s (le code évite |s car ils sont difficiles à gérer dans Batch).

Neil
la source
2

Befunge, 263 243 octets

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

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

Essayez-le en ligne!

La façon dont cela fonctionne est en itérant sur les coordonnées x, y de la zone que nous voulons sortir et en mappant ces valeurs x , y aux coordonnées u , v dans le modèle de puzzle (stocké sur les trois premières lignes du champ de jeu). Ce mappage est réalisé avec les formules de base suivantes:

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

La coordonnée u se répète toutes les 12 colonnes, mais doit également être décalée de 6 toutes les 3 lignes. La coordonnée v se répète toutes les 3 lignes, mais nous ajoutons y==0à la valeur afin que la toute première ligne puisse être rendue comme un cas spécial. Cependant, pour gérer les bords, nous devons introduire une valeur booléenne supplémentaire, e , qui est vraie pour différents emplacements de bord, et qui ajuste les formules comme suit:

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

Ainsi, si nous sommes sur une arête, nous ajoutons 4 à la coordonnée v de manière à utiliser le motif de bord plus simple sur les lignes 5 à 7. Et nous devons aussi maintenant modifier la coordonnée u par 6 plutôt que 12, car ce motif de bord répète toutes les 6 colonnes.

Quant à la valeur e elle-même, cela nécessite une formule assez complexe, car les emplacements des bords englobent une zone quelque peu irrégulière de la bordure du puzzle.

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

Sans entrer dans trop de détails, la ventilation de base est que elr correspond aux emplacements des bords le long des bordures gauche et droite, tandis que etb correspond aux emplacements le long des bordures supérieure et inférieure.

James Holderness
la source
1

JavaScript (ES6), 285 octets

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>

Ceci est un portage de ma réponse Batch, juste pour voir s'il est en concurrence avec la réponse de @ edc65. La longue chaîne ennuyeuse contient des pièces de puzzle. Les six premières pièces représentent deux rangées d'une colonne de l'intérieur de la scie sauteuse. La septième pièce est utilisée pour l'avant-dernière ligne de la scie sauteuse, à la place de la quatrième pièce. La huitième pièce est utilisée sur la deuxième ligne de la scie sauteuse, à la place de la cinquième pièce, et fait également office de bord gauche de la scie sauteuse. La neuvième pièce est la dernière ligne de la scie sauteuse.

Neil
la source