# ASCII ромбическая сетка

27

Напишите кратчайший код, измеряемый счетчиком байтов, чтобы сгенерировать сетку ASCII, состоящую из ромбов, учитывая следующие параметры:

• m - количество полных ромбов в одном ряду
• n - количество рядов
• s - сторона самого маленького ромба
• r - уровень вложенности - сколько ромбов внутри "базовых" (которые являются фоном между пересечениями сетки)

## Примеры

``````1. Input: 5 3 1 0
Output:

/\/\/\/\/\
\/\/\/\/\/
/\/\/\/\/\
\/\/\/\/\/
/\/\/\/\/\
\/\/\/\/\/

A 5x3 grid of rhombi with side 1, no nesting

2. Input: 3 2 2 0
Output:

/\  /\  /\
/  \/  \/  \
\  /\  /\  /
\/  \/  \/
/\  /\  /\
/  \/  \/  \
\  /\  /\  /
\/  \/  \/

A 3x2 grid of rhombi with side 2, no nesting

3. Input: 5 2 1 2
Output:

///\\\///\\\///\\\///\\\///\\\
///\\\///\\\///\\\///\\\///\\\
///\\\///\\\///\\\///\\\///\\\
\\\///\\\///\\\///\\\///\\\///
\\\///\\\///\\\///\\\///\\\///
\\\///\\\///\\\///\\\///\\\///
///\\\///\\\///\\\///\\\///\\\
///\\\///\\\///\\\///\\\///\\\
///\\\///\\\///\\\///\\\///\\\
\\\///\\\///\\\///\\\///\\\///
\\\///\\\///\\\///\\\///\\\///
\\\///\\\///\\\///\\\///\\\///

A 5x2 grid of rhombi with side 1 (the smallest rhombus), level of nesting is 2

4. Input: 4 2 2 1
Output:

//\\  //\\  //\\  //\\
///\\\///\\\///\\\///\\\
//  \\//  \\//  \\//  \\
\\  //\\  //\\  //\\  //
\\\///\\\///\\\///\\\///
\\//  \\//  \\//  \\//
//\\  //\\  //\\  //\\
///\\\///\\\///\\\///\\\
//  \\//  \\//  \\//  \\
\\  //\\  //\\  //\\  //
\\\///\\\///\\\///\\\///
\\//  \\//  \\//  \\//

A 4x2 grid of rhombi with side 2 with level of nesting 1

5. Input: 4 2 3 3
Output:

////\\\\    ////\\\\    ////\\\\    ////\\\\
/////\\\\\  /////\\\\\  /////\\\\\  /////\\\\\
//////\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\
//////\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\
/////  \\\\\/////  \\\\\/////  \\\\\/////  \\\\\
////    \\\\////    \\\\////    \\\\////    \\\\
\\\\    ////\\\\    ////\\\\    ////\\\\    ////
\\\\\  /////\\\\\  /////\\\\\  /////\\\\\  /////
\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\//////
\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\//////
\\\\\/////  \\\\\/////  \\\\\/////  \\\\\/////
\\\\////    \\\\////    \\\\////    \\\\////
////\\\\    ////\\\\    ////\\\\    ////\\\\
/////\\\\\  /////\\\\\  /////\\\\\  /////\\\\\
//////\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\
//////\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\
/////  \\\\\/////  \\\\\/////  \\\\\/////  \\\\\
////    \\\\////    \\\\////    \\\\////    \\\\
\\\\    ////\\\\    ////\\\\    ////\\\\    ////
\\\\\  /////\\\\\  /////\\\\\  /////\\\\\  /////
\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\//////
\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\//////
\\\\\/////  \\\\\/////  \\\\\/////  \\\\\/////
\\\\////    \\\\////    \\\\////    \\\\////

A 4x2 grid of rhombi with side 3, level of nesting 3
``````

Не забудьте отобразить частично видимые ромбы по краям и углам, где это необходимо.

1
@AdmBorkBork Под «вложенностью» я подразумеваю количество ромбов, вписанных в базовые, найденных между пересечениями сетки.
Гален Иванов

@ Луис Мендо - да, это явно связано с моей задачей.
Гален Иванов

@Stewie Griffin: codegolf.stackexchange.com/questions/146747/… - 3-й контрольный пример
sergiol

5
Ох, как мне не хватает моей подушки!
Стьюи Гриффин

Ответы:

17

# SOGL V0.12 , 20 байтов

``````ā.I∫e+H╚╬8}:±№╬8╬¡∙*
``````

Попробуй здесь! Принимает входные данные в обратном порядке того, что они есть в примерах - r, s, n, m.

Объяснение:

``````ā                     push an empty array - canvas
.I∫      }           for each in range(input) (1-indexed)
H                 decrement
╚                create a diagonal of that size
╬8              insert into the canvas
:          create a duplicate of the canvas
±№        reverse it vertically and horizotally
╬8      insert that into the canvas
∙   multiply vertically by the next input
*  multiply horizontally by the next input
``````

2
Это просто удивительно, как вы вообще сжимаете такую ​​программу в 20 байт.
Эрик Outgolfer

1
Это просто блестяще ... +1 от меня за то, что я
побил

Это действительно впечатляет!
Гален Иванов

@ Mr.Xcoder 19 байтов сейчас. Но тогда я `∙*`
Нил

1
Векторизованное повторение строки в древесном угле является достаточно коротким; если бы я мог создать строковое представление алмаза, мне потребовалось бы всего 6 байт, чтобы повторить его. К сожалению, это занимает у меня 50 байтов. С другой стороны, рисование алмаза занимает всего 17 байт, всего на 1 больше, чем SOGL ... но для умножения холста требуется 20 байт.
Нейл

8

# Древесный уголь , 48 39 37 байт

``````ＵＯ⊕Ｉε\Ｆ⊖ＩζＣ¹¦¹‖ＭL≔⊗⁺ＩζＩεδＦ⊖ＮＣδ⁰Ｆ⊖ＮＣ⁰δ
``````

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

``````ＵＯ⊕Ｉε\
``````

Нарисуйте квадрат размера `r + 1`. Это четверть вложенного алмаза размером 1.

``````Ｆ⊖ＩζＣ¹¦¹
``````

Скопируйте квадрат 1 квадрат вправо и вниз, `s - 1`чтобы получить правильный размер.

``````‖ＭL
``````

Отразите это, чтобы стать полным вложенным алмазом.

``````≔⊗⁺ＩζＩεδ
``````

Вычислите размер этого вложенного алмаза.

``````Ｆ⊖ＮＣδ⁰
``````

Скопируйте алмаз в нужное `m - 1`время.

``````Ｆ⊖ＮＣ⁰δ
``````

Скопируйте алмаз вниз `n - 1`раз.

8

# Python 2 , 160 159 158 байт

-1 байт благодаря Джонатану Фреху

``````m,n,s,r=input()
l=~-s*' '+'/'*(r-~r)+~-s*' '
for x in range(n*2):print'\n'.join(m*(l[i:i+s+r]+l.replace(*'/\\')[i:i+s+r][::-1])for i in range(r+s))[::1-x%2*2]``````

Попробуйте онлайн!

При этом используется тот факт, что дном ромба является инвертированная вершина ( `[::-1]`), повторяющаяся `range(n*2)`и использующая `~x%2*2-1`для контроля, является ли она верхней или нижней.
Для верхней (и нижней) правой стороны просто левая сторона инвертирована и заменена `/`на `\`->. `l.replace(*'/\\')..[::-1]`
Для создания шаблона / вложения `~-s*' '+'/'*(1+r*2)+~-s*' '`используется для создания такой строки, ` /// `которая будет повторяться и нарезаться:

``````   '|  //|/  '
' | ///|  '
'  |/// | '
'  /|//  |'  ``````

Я думаю, что `(1+r*2)`может быть `(r-~r)`.
Джонатан Фрех

7

# Юлия 0,60 , 190 байт

``````g(n,m,s,r)=(s+=r+1;f(i,j,u=mod(i-j+r,2s),v=mod(j+i+r,2s))=(" \\/")[abs(u-r)<abs(v-r)?1+(u<=2r):1+2(v<=2r)];
for i=1:2(s-1)m println((f(i+(i-1)÷(s-1),s+j+(j-1)÷(s-1))for j=1:2(s-1)n)...)end)``````

Это функциональное решение, которое вычисляет для каждой пары индексов, `i,j`какой символ должен отображаться.

Попробуйте онлайн!

### иллюстрация

Начните с сетки

``````f(i,j,u=mod(i,2s),v=mod(j,2s))=(" -|*")[1+(u==0)+2(v==0)]
for i=1:2(s-1)m println((f(i-1,j)for j=1:2(s-1)n)...)end

---------*---------*----
|         |
|         |
|         |
|         |
|         |
|         |
|         |
|         |
|         |
---------*---------*----
|         |
|         |
|         |
|         |
|         |    ``````

`r > 0` означает более толстые линии

``````f(i,j,u=mod(i+r,2s),v=mod(j+r,2s))=(" -|*")[1+(u<=2r)+2(v<=2r)]
for i=1:2(s-1)m println((f(i,j)for j=1:2(s-1)n)...)end

**-----*****-----*****--
**-----*****-----*****--
||     |||||     |||||
||     |||||     |||||
||     |||||     |||||
||     |||||     |||||
||     |||||     |||||
**-----*****-----*****--
**-----*****-----*****--
**-----*****-----*****--
**-----*****-----*****--
**-----*****-----*****--
||     |||||     |||||
||     |||||     |||||
||     |||||     |||||
||     |||||     ||||| ``````

Обрабатывать углы, проверяя, какая линия на исходной сетке является ближайшей

``````f(i,j,u=mod(i+r,2s),v=mod(j+r,2s))=(" -|")[abs(u-r)<abs(v-r)?1+(u<=2r):1+2(v<=2r)]
for i=1:2(s-1)m println((f(i,j)for j=1:2(s-1)n)...)end

|-------|||-------|||---
||-----|||||-----|||||--
||     |||||     |||||
||     |||||     |||||
||     |||||     |||||
||     |||||     |||||
||     |||||     |||||
||-----|||||-----|||||--
|-------|||-------|||---
---------|---------|----
|-------|||-------|||---
||-----|||||-----|||||--
||     |||||     |||||
||     |||||     |||||
||     |||||     |||||
||     |||||     |||||  ``````

Фея говорит нам убрать каждую `s-1`строчку

``````f(i,j,u=mod(i+r,2s),v=mod(j+r,2s))=(" -|")[abs(u-r)<abs(v-r)?1+(u<=2r):1+2(v<=2r)]
for i=1:2(s-1)m println((f(i+(i-1)÷(s-1),s+j+(j-1)÷(s-1))for j=1:2(s-1)n)...)end

---||------||------||---
--||||----||||----||||--
||||    ||||    ||||
||||    ||||    ||||
||||    ||||    ||||
||||    ||||    ||||
--||||----||||----||||--
---||------||------||---
---||------||------||---
--||||----||||----||||--
||||    ||||    ||||
||||    ||||    ||||
||||    ||||    ||||
||||    ||||    ||||
--||||----||||----||||--
---||------||------||---``````

Траверс по диагонали и сделано

``````f(i,j,u=mod(i-j+r,2s),v=mod(j+i+r,2s))=(" \\/")[abs(u-r)<abs(v-r)?1+(u<=2r):1+2(v<=2r)]
for i=1:2(s-1)m println((f(i+(i-1)÷(s-1),s+j+(j-1)÷(s-1))for j=1:2(s-1)n)...)end

///\\\  ///\\\  ///\\\
////\\\\////\\\\////\\\\
////\\\\////\\\\////\\\\
///  \\\///  \\\///  \\\
\\\  ///\\\  ///\\\  ///
\\\\////\\\\////\\\\////
\\\\////\\\\////\\\\////
\\\///  \\\///  \\\///
///\\\  ///\\\  ///\\\
////\\\\////\\\\////\\\\
////\\\\////\\\\////\\\\
///  \\\///  \\\///  \\\
\\\  ///\\\  ///\\\  ///
\\\\////\\\\////\\\\////
\\\\////\\\\////\\\\////
\\\///  \\\///  \\\/// ``````

3

## JavaScript (ES6), 154 байта

``````f=
(m,n,s,r)=>[...Array((s+=r)*n*2)].map((_,i)=>[...Array(s*m*2)].map((_,j)=>i/s&1^j/s&1?`\\ `[g(j%s)]:`/ `[g(s-1-j%s)],g=j=>i%s-j>r|j-i%s>r).join``).join`
```````
``````<div oninput=o.textContent=f(+m.value,+n.value,+s.value,+r.value)>
m: <input type=number min=0 id=m><br>
n: <input type=number min=0 id=n><br>
s: <input type=number min=0 id=s><br>
r: <input type=number min=0 id=r></div>
<pre id=o>``````

Непосредственно вычисляет символ в каждой ячейке вывода.

2

# CJam, 44

``````q~:R+,_ff{-zR>}{_W%:~\+"\ /"f=}%_W%Wf%+*f*N*
``````

Попробуйте онлайн

Объяснение:

``````q~           read and evaluate the input
:R+          save the last number in variable R, then add the last 2 numbers (s+r)
,_           make an array [0 1 … s+r-1] and duplicate it
ff{…}        make a matrix, calculating for each (x,y) pair from the 2 arrays:
-z         abs(x-y)
R>         compared with R (1 if greater, 0 if not)
{…}%         transform each row of the matrix:
_W%        duplicate and reverse it
:~         bitwise-NOT each element (0 → -1, 1 → -2)
\+         prepend to the original row
"\ /"f=    replace numbers with characters from this string (by index):
0 → '\'; 1, -2 → ' '; -1 → '/'
this generates the "/\" part
_W%          duplicate the matrix and reverse the rows
Wf%+         reverse each row, then append (by rows) to the original matrix
*            repeat the matrix (by rows) n times
f*           repeat each row m times
N*           join the rows with newlines
``````

2

# C # (.NET Core) , 167 байт

``(c,r,s,n)=>{int w=s+n,i=0,j;var g="";for(;i<r*2*w;i++,g+="\n")for(j=0;j<c*2*w;){int y=i%w,q=(j/w+i/w+1)%2,p=~-w*q+j++%w*(1-2*q);g+=p>y+n|p<y-n?' ':"\\/"[q];}return g;}``

Попробуйте онлайн!

Я удивлен размером, которым я управлял; Я изначально ожидал более долгого решения. Сказав это, я уверен, что есть другие уловки, которые я пропустил.

### DeGolfed

``````(c,r,s,n)=>{
int w=s+n, // rhombus quadrant width, and height
i=0, // string row
j; // string column

var g="";

// go through every character row and column
for(; i < r*2*w; i++, g += "\n")
for(j = 0; j < c*2*w;)
{
int y = i % w, // vertical position in the quadrant
q = ( j / w + i / w + 1) % 2, // Get the rhombus quadrant as a 0 or 1
p = ~-w * q + j++ % w * (1-2*q); // horizontal position in quadrant. the value is either ascending or descending depending on the quadrant

// select which character to use at this [i,j] position
g += p > y + n | p < y - n ? ' ' : "\\/"[q];
}

return g;
}``````

1

# Python 2 , 201 189 байт

``def f(m,n,s,r):Z=range(s+r);R=[r-~min(i,s+~i+r,min(s-1,r))for i in Z];L=[m*(' '*(s+~i)+'/'*R[i]+'  '*(i-r)+'\\'*R[i]+' '*(s+~i))for i in Z];print'\n'.join((L+[l[s+r:]+l[:s+r]for l in L])*n)``

Попробуйте онлайн!

Используется тот факт, что нижняя часть совпадает с верхней, но смещена:

``````Top:       /\/\/\
Bottom:     /\/\/\``````

Сохранено 22 байта благодаря Джонатану Фреху

`s-i-1`может быть `s+~i`, сохраняя два байта. `r+1+min(...`может быть `r-~min(...`, сохраняя еще один. `L=[(...)*m for`может быть `L=[m*(...)for`, сохраняя еще один байт.
Джонатан Фрех

`L+=[...];print'\n'.join(L*n)`можно `print'\n'.join((L+[...])*n)`сохранить еще один байт, в результате чего получается 196 байт .
Джонатан Фрех

195 байт , если также заменить `s+r-i-1`на `s+~i+r`.
Джонатан Фрех

Альтернативная версия 192 байта или версия 191 байта с использованием `exec`форматирования строки.
Джонатан Фрех

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.