어린 시절, 나는이 장난감을 많이 가지고 노는 것을 좋아했습니다.
그들은 아마도 이것들이 예술에 사용되도록 의도되었지만, 항상 수학에 사용했습니다! 도형, 패턴 등 한 번, 나는이 도전을 받았다 :
녹색 삼각형 타일을 사용하지 않고 삼각형을 만듭니다.
이 도전은 내가 3 개의 사다리꼴로 그것을하는 정말 아름답고 간단한 방법을 발견 할 때까지 가장 오랫동안 저를 비 틀었습니다.
/\
/_/\
/__\_\
이제이 삼각형을 가지고 회전 시키십시오 :
______
\ \__/
\/ /
\/
이 두 개의 삼각형을 사용하여 더 큰 삼각형을 만들 수 있습니다. 높이 2의 삼각형은 다음과 같습니다.
/\
/_/\
/__\_\
/\ \__/\
/_/\/ /_/\
/__\_\/__\_\
그리고 여기에 높이 3-7의 삼각형이 있습니다 :
#3
/\
/_/\
/__\_\
/\ \__/\
/_/\/ /_/\
/__\_\/__\_\
/\ \__/\ \__/\
/_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\
#4
/\
/_/\
/__\_\
/\ \__/\
/_/\/ /_/\
/__\_\/__\_\
/\ \__/\ \__/\
/_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\
/\ \__/\ \__/\ \__/\
/_/\/ /_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\/__\_\
#5
/\
/_/\
/__\_\
/\ \__/\
/_/\/ /_/\
/__\_\/__\_\
/\ \__/\ \__/\
/_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\
/\ \__/\ \__/\ \__/\
/_/\/ /_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\/__\_\
/\ \__/\ \__/\ \__/\ \__/\
/_/\/ /_/\/ /_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\/__\_\/__\_\
#6
/\
/_/\
/__\_\
/\ \__/\
/_/\/ /_/\
/__\_\/__\_\
/\ \__/\ \__/\
/_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\
/\ \__/\ \__/\ \__/\
/_/\/ /_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\/__\_\
/\ \__/\ \__/\ \__/\ \__/\
/_/\/ /_/\/ /_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\/__\_\/__\_\
/\ \__/\ \__/\ \__/\ \__/\ \__/\
/_/\/ /_/\/ /_/\/ /_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\/__\_\/__\_\/__\_\
#7
/\
/_/\
/__\_\
/\ \__/\
/_/\/ /_/\
/__\_\/__\_\
/\ \__/\ \__/\
/_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\
/\ \__/\ \__/\ \__/\
/_/\/ /_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\/__\_\
/\ \__/\ \__/\ \__/\ \__/\
/_/\/ /_/\/ /_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\/__\_\/__\_\
/\ \__/\ \__/\ \__/\ \__/\ \__/\
/_/\/ /_/\/ /_/\/ /_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\/__\_\/__\_\/__\_\
/\ \__/\ \__/\ \__/\ \__/\ \__/\ \__/\
/_/\/ /_/\/ /_/\/ /_/\/ /_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\/__\_\/__\_\/__\_\/__\_\
도전
숫자를 취하는 함수 작성 프로그램 또는 N 과 높이의 삼각형 삼각형 적은 출력 N을 . 각 줄의 후행 공백은 허용되며 최대 하나의 후행 또는 선행 줄 바꿈도 허용됩니다. IO는 합리적인 형식 일 수 있습니다. 입력은 양의 정수로 보증되므로 음수, 소수, 비 숫자 등을 걱정할 필요가 없습니다.
바이트 단위의 최단 답변이 승리합니다!
답변
CJam, 47
ri_"/__\_\/_/\/ /\ \__"6/f**eeW%{_S.*s\~,\-<N}/
설명:
ri_ read the input, convert to integer and duplicate
"…" push that string, containing the repeating pattern
(3 lines in reverse order, concatenated)
6/ split into (3) lines of 6 characters
f* multiply (repeat) each line n times
* repeat the array of 3 lines n times
at this point we have an array of 3*n strings with 6*n characters each
ee enumerate the array (obtaining an array of [index string] pairs)
W% reverse the array
(so the lines are in correct order and indices in reverse order)
{…}/ for each [index string] pair
_ duplicate the pair
S.* vectorized-multiply with " "
this effectively replaces the index with a string of <index> spaces
s convert the pair to string, effectively concatenating the spaces
with the string
\ swap with the other copy of the [index string] pair
~, dump the index and string on the stack and get the string length
\- subtract the index from it - this is the desired line length
< cut the concatenated string to that length
N add a newline
답변
루비, 79
->n{1.upto(n*=3){|i|puts (' '*(n-i)).ljust(n+i,'/__\_\/\ \__/_/\/ '[i%3*6,6])}}
A. (-4 바이트, -1
+1
) (인덱스 0으로 변경 .times
한 인덱스에) ( 1.upto
)
B. (-5 바이트)는 6 개의 문자열 3 개 배열에서 18 문자 문자열의 6 문자 하위 문자열 선택으로 변경되었습니다.
C. (-1 바이트) m=n*3
->n*=3
D. (-5 바이트)는 5 개의 이중 백 슬래시를 모두 단일 백 슬래시로 줄였습니다 (부분 A에 필요한 문자열을 다시 정렬하여 가능)
루비, 94
->n{(m=n*3).times{|i|puts (' '*(m-i-1)).ljust(m+i+1,[ '/\\ \\__','/_/\\/ ','/__\\_\\'][i%3])}}
설명
기본 단위는 다음과 같이 3×6 다이아몬드입니다 (명확성을 위해 각 행의 마지막 문자가 복제 됨).
/\ \__/
/_/\/ /
/__\_\/
이 패턴의 적절한 창을 표시하기 만하면됩니다. 루비를 ljust
사용하면 공백뿐만 아니라 모든 문자열을 채울 수 있습니다. 일반적으로 ljust
끝에 공백을 추가하여 인쇄 가능한 문자 문자열을 채우는 데 사용되지만 여기서는 뒤집을 수 있습니다. 끝에 인쇄 가능한 문자를 추가하여 공백 문자열을 채 웁니다.
테스트 프로그램에서 ungolfed
f=->n{
(m=n*3).times{|i| #for each line of the triangle
puts (' '*(m-i-1)). #print m-i-1 spaces,
ljust(m+i+1,[ '/\\ \\__', #left justified and padded to total length m+i+1
'/_/\\/ ', #by one of these three strings
'/__\\_\\'][i%3])
}
}
f[gets.to_i]
답변
망막 , 150 (122) 118 바이트
그건 그렇고,이 도전에 대한 결과는 훌륭해 보입니다!
입력이 단항입니다. 출력에는 후행 줄 바꿈이 포함됩니다. 이 코드는 ISO 8859-1 인코딩을 사용합니다. 두 번째 줄의 후행 공간에 유의하십시오.
(?=_\\¶.*1)
_\/__\
(?=/_/\\¶.*1)
/_/\/
(^|__)(?=/\\¶.*1)
$1/\ \__
ms}`(.*1*)1
/\¶/_/\¶/__\_\¶$1
m`^(?=(.*¶)*.)
$#1$*
설명
좀 더 깊이있는 설명을 원하신다면 채팅으로 의견을 말하거나 메시지를 보내십시오.
(?=_\\¶.*1) # Matches the start of the 3rd line of every triangle
/__\_\ # and prepends another layer if needed
(?=/_/\\¶.*1) # 2nd line of each triangle
/_/\/
(^|__)(?=/\\¶.*1) # 1st line of each triangle
$1/\ \__
ms}`(.*1*)1 # This and above in a multi-single-line loop.
/\¶/_/\¶/__\_\¶$1 # This stage adds a flattened triangle on top
m`^(?=(.*¶)*.) # Prepend a space for every line following -1
$#1$*
32 바이트 할인 된 Martin에게 감사합니다.
답변
Tarmo의 ASCII 인쇄 언어, 46 바이트 (비경쟁)
1 /\| /_/\|/__\_\2 \__|/ 0n{n-a-1{~}1a{2#1}$}
CJam과 같은 이상한 프로그래밍 언어를 살펴보면 복잡하고 부자연스럽고 비밀스러운 언어가 얼마나 어색한 지 모르겠습니다. 결과적으로 ASCII 패턴 인쇄를위한 고유 한 언어를 만들었습니다.
기본 아이디어는 첫 번째 패튼을 정의한 다음 동일한 종류의 문자 ‘1’또는 ‘2’또는 숫자를 사용하여 인쇄 할 수 있으며 자신 만의 인쇄 패턴을 정의 할 수 있다는 것입니다.
패턴이 정의되면 (숫자부터 끝까지 시작)-다음 숫자는 패턴 인쇄를 실행합니다.
예를 들어
1 /\| /_/\|/__\_\01
다음과 같은 출력 :
/\
/_/\
/__\_\
패턴 1을 정의한 후 바로 인쇄합니다. 패턴은 ‘|’로 구분 된 모든 것을 정의합니다. 캐릭터. 끝에 0-패턴 종료와 같은 역할을합니다.
‘$’와 같은 특수 문자는 줄 바꿈으로 예약되고 ‘~’는 특정 패턴의 간격-절반으로 예약됩니다.
1 /\| /_/\|/__\_\01$~11$~1~11
다음과 같은 텍스트를 출력합니다 :
/\
/_/\
/__\_\
/\
/_/\
/__\_\
/\
/_/\
/__\_\
다음은 for 루프입니다. 그것은 쉽게 볼 수 있어야합니다-그래서 for 루프에 {} 괄호를 유지했지만 변수 이름은 자동으로 이름이 지정되므로 첫 번째 괄호는 ‘a’변수, 두 번째 ‘b’등을 사용합니다. 반복은 항상 0에서 특정 숫자로 진행되며 해당 숫자는 {} 괄호 앞에 정의됩니다.
‘n’은 전체 함수 입력을 위해 예약 된 변수입니다.
따라서 코드 :
1 /\| /_/\|/__\_\0n{1$}
출력합니다 (n == 4).
/\
/_/\
/__\_\
/\
/_/\
/__\_\
/\
/_/\
/__\_\
/\
/_/\
/__\_\
그리고 ‘#’은 트림 리드 공백을위한 특수 수정 자입니다.
그리고 마지막으로 전체 솔루션 :
DrawPatterns.cs :
using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using Microsoft.CSharp;
class DrawPatterns
{
//Command line parameters - for example like this: "1 /\| /_/\|/__\_\2 \__|/ 0n{n-a-1{~}1a{2#1}$}" 3
static Dictionary<char, String[]> patterns = new Dictionary<char,string[]>();
static string Tabs(int n)
{
if( n < 0 ) n = 0;
String r = "";
for( int i = 0; i < n ; i++ )
r += " ";
return r;
}
static int[] left = new int[10];
static int top = Console.CursorTop;
static int lastTop = Console.CursorTop;
static public void DoPrint(char c, char modifier = ' ')
{
if (c == '$')
{
for (int i = 0; i < left.Length; i++)
left[i] = 0;
top = lastTop + 1;
return;
}
if (!patterns.ContainsKey(c))
return;
if (modifier == '½' || modifier == '~')
{
int maxSize = patterns[c].Select(x => x.Length).Max();
for( int i = 0; i < left.Length; i++ )
left[i] += maxSize / 2;
return;
}
int iLine = 0;
foreach (var l in patterns[c])
{
Console.SetCursorPosition(left[iLine], top + iLine);
if( top + iLine > lastTop )
lastTop = top + iLine;
String s = l;
if (modifier == '#')
s = s.TrimStart(' ');
Console.WriteLine(s);
left[iLine] += s.Length;
iLine++;
}
}
static void Main(string[] _args)
{
List<String> args = _args.ToList();
String todo = "";
String code = "";
char nextVar = 'a';
String lf = "\r\n";
int align = 1;
char lastModifier = ' ';
int nextArg = 1;
Dictionary<String, String> argValues = new Dictionary<string,string>();
bool bDebug = false;
if (args.Count != 0 && args[0].ToLower() == "-d")
{
bDebug = true;
args.RemoveAt(0);
}
if (args.Count == 0)
{
Console.WriteLine("Usage: DrawPatterns.cs [options] \"script\" <arguments to script>");
Console.WriteLine("[options] allowed:");
Console.WriteLine("-d - debug");
return;
}
String prog = args[0];
for( int i = 0; i < prog.Length; i++ )
{
char c = prog[i];
// Define pattern.
if (c >= '0' && c <= '9' && !patterns.ContainsKey(c))
{
String p = Regex.Match(prog.Substring(i + 1), "[^0-9]*").Groups[0].Value;
patterns[c] = p.Split('|');
i += p.Length;
if( prog[i + 1] == '0' ) i++;
continue;
}
String procRemain = prog.Substring(i);
// modifier specified, but pattern number is not provided - use first pattern.
if( lastModifier != ' ' && ( c < '0' || c > '9' ) )
{
code += Tabs(align);
code += "print('1' , '" + lastModifier + "');" + lf;
lastModifier = ' ';
}
switch ( c )
{
case '{':
code += Tabs(align);
code += "for ( int " + nextVar + " = 0; " + nextVar + " < " + todo + " ; " + nextVar + "++ )" + lf;
// Check for all variable names if they can be used in program.
foreach ( var m in Regex.Matches(todo, "[a-zA-Z_][a-zA-Z0-9_]*", RegexOptions.Singleline) )
{
String varName = m.ToString();
if( varName.Length == 1 && varName[0] <= nextVar )
// Already declared as a loop.
continue;
if( argValues.ContainsKey(varName ) )
continue;
if( nextArg >= args.Count )
{
Console.WriteLine("Insufficient parameters provided to script - argument '" + varName + "' value is needed");
return;
}
argValues[varName] = args[nextArg];
nextArg++;
}
code += Tabs(align);
code += "{" + lf;
nextVar++;
todo = "";
align++;
break;
case '}':
align--;
code += Tabs(align);
code += "}" + lf;
break;
default:
if (((c >= '0' && c <= '9') || c == '<' || c == '$') && todo == "")
{
code += Tabs(align);
code += "print('" + c + "' , '" + lastModifier + "');" + lf;
lastModifier = ' ';
continue;
}
if (c == '½' || c == '~' || c == '#')
{
lastModifier = c;
continue;
}
if( c == '\r' || c == '\n' )
continue;
todo += c;
break;
}
} //for
String code2 = "";
code2 += "using System;" + lf;
code2 += "public class ExecClass { static void Exec( Action<char, char> print";
object[] invokeArgs = new object[ argValues.Count+1];
invokeArgs[0] = new Action<char, char>(DoPrint);
int iValueIndex = 1;
foreach ( var kv in argValues )
{
code2 += ",";
code2 += "int " + kv.Key;
invokeArgs[iValueIndex] = Int32.Parse(kv.Value);
iValueIndex++;
}
code2 += ") {" + lf;
code2 += code;
code2 += "} };";
if( bDebug )
{
int line = 1;
String lineNumberedCode =Regex.Replace(code2, "^(.*)$",
delegate(Match m) { return (line++).ToString("d2") + ": " + m.Value; },
RegexOptions.Multiline
);
Console.WriteLine(lineNumberedCode);
Console.WriteLine();
Console.WriteLine();
}
left[0] = Console.CursorLeft;
for( int i = 1; i < left.Length; i++ )
left[i] = left[0];
top = Console.CursorTop;
try
{
var compileResult = new CSharpCodeProvider().CompileAssemblyFromSource( new CompilerParameters() { GenerateExecutable = false, GenerateInMemory = true }, code2);
if (compileResult.Errors.HasErrors)
{
foreach (CompilerError ce in compileResult.Errors)
{
if (ce.IsWarning) continue;
Console.WriteLine("{0}({1},{2}: error {3}: {4}", ce.FileName, ce.Line, ce.Column, ce.ErrorNumber, ce.ErrorText);
}
return;
}
var method = compileResult.CompiledAssembly.GetType("ExecClass").GetMethod("Exec", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
method.Invoke(null, invokeArgs);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.SetCursorPosition(1, lastTop);
Console.WriteLine();
Console.WriteLine();
} //Main
}
다음과 같은 명령 행 인수를 사용하십시오. -d “1 / \ | / _ / \ | / ___ \ 2 __ | / 0n {na-1 {½} 1a {2 # 1} $}”3
이것을 출력합니다 :
01: using System;
02: public class ExecClass { static void Exec( Action<char, char> print,int n) {
03: for ( int a = 0; a < n ; a++ )
04: {
05: for ( int b = 0; b < n-a-1 ; b++ )
06: {
07: print('1' , '~');
08: }
09: print('1' , ' ');
10: for ( int c = 0; c < a ; c++ )
11: {
12: print('2' , ' ');
13: print('1' , '#');
14: }
15: print('$' , ' ');
16: }
17: } };
/\
/_/\
/__\_\
/\ \__/\
/_/\/ /_/\
/__\_\/__\_\
/\ \__/\ \__/\
/_/\/ /_/\/ /_/\
/__\_\/__\_\/__\_\
답변
자바 스크립트 (ES6), 119 바이트
n=>`,/\\ \\__,/_/\\/ ,/__\\_\\`[r=`repeat`](n).split`,`.map((s,i)=>` `[r](n*3-i)+s[r](n).slice(0,i*2)).slice(1).join`\n`
어디 \n
리터럴 개행 문자를 나타냅니다. n*3
공백과 줄 바꿈이 있는 선행 행 이 허용되는 경우 .slice(1)
9 바이트를 절약하기 위해 제거 할 수 있습니다.
답변
파이썬 2, 118 바이트
def f(n,s=["/\\ \\__","/_/\\/ ","/__\\_\\"]):
print'\n'.join(map(lambda x:' '*(n*3-x)+(n*s[x%3])[:x*2+2],range(n*3)))
Level River St의 Ruby 답변과 비슷한 접근 방식 .
답변
파이썬 2, 142 바이트
def f(n,m):return f(n-1,m+3)+[' '*(m+x)+(y*n)[x*2:]for x,y in((2,' \\__/\\'),(1,'/ /_/\\'),(0,'/__\\_\\'))]if n else[]
print '\n'.join(f(n,0))
원리는 다른 답변과 매우 유사합니다. 반복 된 세 줄을 가져 와서 삼각형을 얻기 위해 일부를 잘라서 왼쪽에 채울 필요가있는 방식으로 레이어를 묶으십시오.