指定したサイズのキューブネットを印刷します

26

チャレンジ

サイズsを指定すると、ハッシュシンボル（#）とスペース（）で構成されるそのサイズのキューブネットを印刷します。

例：

1:
  #
# # #    
  #
  #

2:
    # #
    # #
# # # # # #
# # # # # #
    # #
    # #
    # #
    # #

3:
      # # #
      # # #
      # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
      # # #
      # # #
      # # #
      # # #
      # # #
      # # #

ネットは、実際には、キューブに折りたたむことができる任意の有効なキューブネットにすることができます。たとえば、

    # #
    # #
# # # # # # # #
# # # # # # # #
    # #
    # #

    # # # #
    # # # #
    # #
    # #
    # #
    # #
# # # #
# # # #

ルール

  • 結果のネットは、幾何学的に有効でなければなりません（キューブに折り畳み可能）
  • 禁止されている標準的な抜け穴
  • ルールを注意深く読む
  • これはcode-golfで、最短の回答が勝ちますが、選択されません
code-golf  string  ascii-art  kolmogorov-complexity  geometry 
— dkudriavtsev
ソース
1
先頭/末尾のスペース/改行はありますか？
— クリチキシリトス
@KritixiLithosはい
— dkudriavtsev
13
— -xnor
3
ルールを注意深く読んでいない場合はどうなりますか？
— -steenbergh
1
@steenberghその後、あなたのソリューションは無効です
— -dkudriavtsev

回答:

23

Python 2、47バイト

n=input()
for c in 1,4,1:exec"print'# '*c*n;"*n

オンラインでお試しください！

左揃えに選択されたこのネットを印刷します。

# # 
# # 
# # # # # # # # 
# # # # # # # # 
# # 
# #

行には、nまたはの4*nコピーがあり'# 'ます。のそれぞれについて1,4,1、行n数分のコピーを印刷nしnます。持つexec内部ループforループすることは無駄なようだが、私は良く見えませんでした。

私がテストした代替案：

lambda n:('# '*n*3+'\n')*n+('  '*n+'# '*n+'\n')*3*n

lambda n:('# '*n*3+'\n')*n+(' '*4*n+'# '*n*3+'\n')*n

def f(n):
 for c in[3]*n+[1]*3*n:print('# '*c*n).center(6*n)

def f(n):
 for c in[4]*n+[0]*n:print' '*c*n+'# '*n*3

def f(n):
 for c in[1]*n+[4]*n+[1]*n:print'# '*c*n

def f(n):
 c=1;exec("print'# '*c*n;"*n+"c^=5;"*n)*3

def f(n):
 for i in range(3*n):print'# '*[1,4,1][i/n]*n

def f(n):
 for c in 1,4,1:print('# '*c*n+'\n')*n,

def f(n):
 for c in 1,4,1:exec"print'# '*c*n;"*n

（def関数はすべてプログラムとして1つ短くすることができます。）

— xnor
ソース
8

オクターブ、58 44 42 32バイト

@(n)[z=repmat('# ',n);z,z,z,z;z]

@xnorのpythonの回答に一部影響を受けています。

z=repmat('# ',n);

入力2の結果に対して '＃'のsqureパターンを作成し、次のパターンを作成します。

# #             
# # 

y=[z,z,z,z];

4つzのsは水平に連結されます：

# # # # # # # # 
# # # # # # # # 

[z;y;z]

zそしてy、z垂直に連結されます

オンラインでお試しください！

# #             
# #             
# # # # # # # # 
# # # # # # # # 
# #             
# #

前の答え：

@(n){h(1:n,1:2:n*6)=1;h(1:n*4,n*2+1:2:4*n)=1;' #'(h+1)}{3}

オンラインでお試しください！

T字型を生成します

# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
      # # #      
      # # #      
      # # #      
      # # #      
      # # #      
      # # #      
      # # #      
      # # #      
      # # #
— rahnema1
ソース
6

Mathematica、77 60 52バイト

8バイト離れたゴルフをしてくれたMartin Enderに感謝します！

{±s_:=s~Table~#;b=±{a=±"# ","
"},±{a,a,a,a,"
"}}<>b&

正の整数引数を取り、#改行（末尾の改行を含む）を含む文字列を返す名前のない関数。各行には末尾スペースもあります。まず±、入力#時間を繰り返す関数として定義します。そして、これは（これは入力ではなく文字です！）aと定義され、それから短い行のセットであると定義され、長い行のセットです。（どちらの場合も、一致する引用符の間にリテラルの改行があります。）最終的に、結果の文字列のリストと短い行のセットの2番目のコピーが連結されます。次の場合の出力例（xnorの答えは、この方向がゴルファーであることを教えてくれました）：±"# "#b#±{a,a,a,a}<>n#<>b#=2

# #     
# #     
# # # # # # # # 
# # # # # # # # 
# #     
# #

この実装の以前のバージョン：

""<>(±s_:=s&~Array~#;{b=±{a=±"# ",n="\n"},±{a,a,a,a}<>n,b})&

元の提出：

""<>If[(m=n~Mod~t)==0,"\n",If[n<t#||#<m<=2#,"# ","  "]]~Table~{n,4(t=3#+1)#}&

列うち構築4*(3#+1)のいずれかでこれらの各々の部分を、"# "、" "、または"\n"; インデックスに基づいて、使用するピースを単純に計算しますn。次の場合の出力例#=2：

# # # # # # 
# # # # # # 
    # #     
    # #     
    # #     
    # #     
    # #     
    # #
— グレッグ・マーティン
ソース
5

JavaScript（ES6）、59バイト

f=
n=>`141`.replace(/./g,m=>`${`# `.repeat(n*m)}\n`.repeat(n))
<input type=number oninput=o.textContent=f(this.value)><pre id=o>
スニペットを展開

出力には、各行の末尾の末尾スペースと末尾の改行が含まれます。

— ニール
ソース
5

ルビー、36バイト

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}

使用法：

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}
f[3]
# # #
# # #
# # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # #
# # #
# # #

ルビー、38バイト

この形状はRubyではより長いですが、いくつかの言語ではより短いものがあると予想しています。

->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}

使用法：

g=->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}
g[3]
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #

両方の答えは、文字列の配列を返すことを許可されている場合は短くすることができます。

— レベルリバーストリート
ソース
文字列を返すことは、出力の有効な形式と見なされます。
— dkudriavtsev
4

Scala、56バイト

(n:Int)=>Seq(1,4,1)map("# "*_*n+"\n")map(_*n)mkString ""
— jaxad0127
ソース
4

JavaScript（ES6）、71

n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

テスト

f=
n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

function update() {
  O.textContent=f(I.value)
}

update()
<input id=I type=number value=3 oninput='update()'><pre id=O></pre>
スニペットを展開

— edc65
ソース
よくわかりませんが、ハッシュとともにスペースを出力する必要があると思います。（また、答えの最初の編集にスペースを含めないという誤りを犯しました）
— Kritixi Lithos
@KritixiLithosええ、わかった。ありがとう
— -edc65
4

V、24 23 20 18 20バイト

Ài# ddÀpLyGïp3PGïp

すべての隠されたキャラクターが表示されている状態で

Ài# ^[ddÀp^VLyGïp3PGoïp

^[is 0x1b（エスケープ文字リテラル）および^Vis 0x16（C-v）

オンラインでお試しください！

Äこの新しいVプルではコマンドにバグがあったため、バイト数を増やす必要がありました

この形式の出力：

# 
# # # # 
#

主要な改行で

Hexdump：

00000000: c069 2320 1b64 64c0 7016 4c79 47ef 7033  .i# .dd.p.LyG.p3
00000010: 5047 ef70                                PG.p

説明

Ài# ^[              " Argument times insert "# "
ddÀp                " Argument times duplicate line

ネットの1つの面が完成したので、ネットを作成する必要があります

^VLy                " Copy the face
Gïp                 " Paste it at the end of buffer
3P                  " Paste 3 times (these form the line)
Gïp                 " Paste at end of buffer again

スペースを出力しない場合の代替ソリューション：

21 20 18 16 18バイト

Àé#ddÀpLyGïp3pGïp

（最上位ソリューションと同じ理由で、このTIOリンクが変更されます）

オンラインでお試しください！

— クリチキシリソス
ソース
4

V、14バイト（非競合）

Ài# 5Ù4JjòÀÄk

オンラインでお試しください！

00000000: c069 2320 1b35 d934 4a6a f2c0 c46b       .i# .5.4Jj...k

なんらかの理由で、この挑戦​​は多くのバグを発見しました。すべて修正されたので、このバージョンは残念ながら競合していませんが、ずさんなコーディングに対応するために大量のバイトを追加する必要がない場合、このチャレンジに対するVの回答がどのように見えるかを見るのは素晴らしいことです。

説明：

À                   " Arg 1 times:
 i# <esc>           "   Insert the string "# "
         5Ù         " Make 5 copies of this line, and put the cursor on the second copy
           4J       " Join four of these lines together
             j      " Move down to the last line
              ò     " Recursively:
               ÀÄ   "   Make Arg 1 copies of this line
                 k  "   And move up a line
— DJMcMayhem
ソース
公平を期すために、このJ問題は見知らぬコーディングではなく、nvimのデフォルトだったと思いますか？
— nmjcman101
ええ、それは本当です。しかし、複製演算子は間違いなくずさんでした。ありがたいことに、この新しいバージョンははるかに簡単です。
— DJMcMayhem
4

ゼリー、20 19バイト

”#xẋ³Wẋ³K€Y
141DÇ€Y

オンラインでお試しください！

44874（steenbergh）に感謝します。

MUDDYFISHヘルプを発信できません！

これはゴルフ可能ですか？20 19バイトは多すぎる、リンク1を参照してください。

説明：

”#xẋ³Wẋ³K€Y Helper link. Arguments: z
”#          Character #.
            y (implicit)
  x         Repeat each element of y x times.
    ³       1st command-line argument.
   ẋ        Repeat x y times.
     W      Wrap z.
       ³    1st command-line argument.
      ẋ     Repeat x y times.
        K   Join z on spaces.
         €  Map this link on x.
          Y Join z on newlines.

141DÇ€Y Main link. Arguments: 0
141     Integer 141.
   D    Convert z to base 10.
    Ç   The above link as a monad.
     €  Map this link on x.
      Y Join z on newlines.
— エリック・ザ・アウトゴルファー
ソース
今はV対Jellyです:)
— Kritixi Lithos
@KritixiLithos Nah、あなたの解決策が最初でした。
— エリックアウトゴルファー
Vは18バイトになりました:)
— Kritixi Lithos
@オペランドを使用せずにx自分自身にスワップすることで、バイトをドロップできます”#xẋ³Wẋ³K€Y。
— -steenbergh
3

炭、20バイト

ＮλＧ↑λ←×⁶λ↓λ# ＤＭ×⁴λ←

コードはスペースで終了します。オンラインでお試しください！

説明

木炭は、ASCIIアートに特化した言語です。また、不完全でバグが多く、文書化も不十分です。言うに足りますが、これは本来のことをする前にかなりの試行錯誤をしました。

  • Ｎλに数値を入力しλます。
  • Ｇこれは多角形コマンドで、ここで四角形を描画するために使用します。↑λ←×⁶λ↓λ多角形の境界線を指定します：上向きλステップ、左向き6回λステップ、下向きλステップ （これはλ、λブロックごとに3つ並んでいます。）長方形の下端は推測されます。次に、ポリゴンに文字列が入力されます# 。
  • Ｄ 現在のキャンバスを標準出力にダンプし、次のような結果になります。
 ＃＃＃＃＃＃＃＃＃
 ＃＃＃＃＃＃＃＃＃
 ＃＃＃＃＃＃＃＃＃
  • Ｇコマンドの後、カーソルはキャンバスの左下隅にあります。Ｍ×⁴λ←左に4倍ずつ移動しλます（2 λby λブロックに相当）。
  • そこにスペースを出力し、キャンバスを正しい量だけ左に拡張します。
  • プログラムの最後に、キャンバスが（再び）stdoutに送信されます。
             ＃＃＃＃＃＃＃＃＃
             ＃＃＃＃＃＃＃＃＃
             ＃＃＃＃＃＃＃＃＃

それらをまとめると、キューブネットができました。

— DLosc
ソース
うわー、当時本当に苦労しなければなりませんでした！（Oblongは数週間後まで追加されませんでした。）
— ニール
2

パイク、16バイト

uAD,sXF**"#

ここで試してみてください！

に相当

1 4 1]3AD,sXF**"#

印刷できないため

これは、いくつかのトリックを使用してバイト数を減らします。

  • リストを表すためにいくつかの印刷不可能なものを使用します [1, 4, 1]
  • XF 自動的に出力をスタックにダンプします
  • "#最後の文字列はlastと交換されます。*つまり、終了"は不要です。これは、最後のトークンが文字列の場合に暗黙的に発生します。


u                -      [1, 4, 1]
     AD          -     apply(*, ^, input)
       ,         -    zip(^)
        s        -   sum(^)
          F**"#  -  for i in ^:
           *     -    ^ * input
            *    -   ^ * v
             "#  -    "# "
         X       - splat(^)
— 青い
ソース
2

Python 2、 68の 71 65バイト

-6 @sagikspのおかげで

def f(i,c=1):
 print(' '*i*4,'')[c>i]+'# '*i*3
 if i*2>c:f(i,c+1)

オンラインでお試しください！

@xnorに勝つ方法が見つからない場合は、単に代替アプローチとして再帰関数を投稿します。f（5）プリントの場合

                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # #

このパターンが選択されたのは、他のすべてとは異なり、2つの部分に分割できるためです。

— エルペドロ
ソース
2
スペースはどこにありますか？
— -dkudriavtsev
1
出力にスペースがないと、これは無効です。
— メゴ
スペースを追加する私の間違い+3。更新しました。
— エルペドロ
1
実際、なぜjが必要なのですか？iに関して全体を再定義し、最大6バイト節約できます！
— sagiksp
@sagiksp-ありがとう。提案を使用して更新しました。
— エルペドロ
2

PHP、64 62バイト

Christophのおかげで2バイト節約できました。

while($a="282"[$i++/$s=$argv[1]]*$s)echo str_pad("
",$a,"# ");

次のようなネットを印刷します。

# #
# #
# # # # # # # #
# # # # # # # #
# #
# #

（先頭に改行がある）

— user63956
ソース
1
while($a="282"[$i++/$s=$argv[1]]*$s)echo str_pad("\n",$a,"# ");2バイト節約します。
— クリストフ
1

バッチ、111バイト

@set s=
@set i=@for /l %%i in (1,1,%1)do @
%i%call set s=%%s%% #
%i%echo%s%
%i%echo%s%%s%%s%%s%
%i%echo%s%
— ニール
ソース
1

網膜、 39 37バイト

Retinaを使用するのはこれが初めてですが、私はまだ物事の方法を理解しようとしています。

.+
$*#
#
# 
\`# 
$_¶
G`.
)*%`^
$_$_$_

（4行目と5行目の後に2つの末尾スペースがあります）

2バイトのゴルフをしてくれたMartin Enderに感謝します！

オンラインでお試しください！

— レオ
ソース
@MartinEnderありがとう、私はその要件に気付いていませんでした、今では正しいはずです。これをゴルフしようとする方法について何か提案はありますか？
— レオ
素晴らしいアイデアはあまりありませんが、tio.run / nexus /…は2バイト節約します。出力フラグを持つグループ内のすべてをラップすることで、末尾の改行を回避できます（グループはプログラムの最後のものなので、出力フラグはデフォルトで非サイレントになります）。他のバイトは$_、空の行を削除した後にいくつかのことを切り替えることにより、下部の4番目を回避します。tio.run/nexus/…は同じバイト数ですが、少しいです。
— マーティンエンダー
@MartinEnderヒントをありがとう、そしてこの言語にも感謝します、本当にいいです！
— レオ
優しい言葉をありがとう。:) 質問がある場合や、話し合いたい場合は、チャットルームがあります。現在はかなり静かですが、質問がある場合に備えて凍結しないようにしています（いつでも私にpingできるはずです）。
— マーティンエンダー
1

QBIC、52 67 40バイト

完全な書き換え：

:[a*3|G=G+@#`][a*2|G=G+@ `][a|?G][a|?_fG

これは今このパターンを使用します：

###--
--###

どこ -スペースで満たされています。

:        Read 'a' from the command line        > Assume 3
[a*3|    Create 3 segments times 'a' filling   > 3*3 = 9
G=G+@#`] Define A$ to be '#' and add this to G > G = "#########" 
[a*2|    Create 2 segments times 'a' spacer
G=G+@ `] Define B$ to be ' ' and add this to G > G = "#########       " 
[a|      FOR d == 1; d <= a; d++
?G]      Display G$:
            "#########       " 
            "#########       " 
            "#########       " 
[a|      FOR e == 1; e <= a; e++
?_fG     Display G$ in reverse (_f...|):
            "      #########" 
            "      #########" 
            "      #########" 
         (For loop and function call to Flip impicitly closed by QBIC)
— ステンバーグ
ソース
— エリックアウトゴルファー
@EriktheOutgolferが更新されました。
— -steenbergh
2
チャレンジに適切な言語名！
— FlipTack
1

ピップ、28 17 16バイト

15バイトのコード、-nフラグの場合は+1 。

"# "Xa*_RLaM141

コマンドライン引数としてサイズを取ります。オンラインでお試しください！

説明

                 a is 1st cmdline arg
       _         Build a lambda function
     a*          (a) times argument
"# "X            Repeat string "# " that many times
        RLa      Wrap in a list and repeat list (a) times
           M141  Map that function to the characters of 141
                 Autoprint (-n flag separating list items with newlines)

以下は、データがどのように変更されるかを正確に示しているわけではありませんが、基本的な考え方を示しています（for a=2）。

141

[1;4;1]

[2;8;2]

["# # ";"# # # # # # # # ";"# # "]

[["# # ";"# # "];["# # # # # # # # ";"# # # # # # # # "];["# # ";"# # "]]

# # 
# # 
# # # # # # # # 
# # # # # # # # 
# # 
# #
— DLosc
ソース
0

05AB1E、13バイト

D141S×S*„# ×»

オンラインでお試しください！

説明

入力例 n=2

D              # duplicate input
               # STACK: 2, 2
 141S          # push the list [1,4,1]
               # STACK: 2, 2, [1,4,1]
     ×         # repeat each item in the list input_no times
               # STACK: 2, [11, 44, 11]
      S        # split into list of digits
               # STACK: 2, [1, 1, 4, 4, 1, 1]
       *       # multiply each digit with input
               # STACK: [2, 2, 8, 8, 2, 2]
        „# ×   # repeat the string "# " for each item in the list
               # STACK: ['# # ','# # ','# # # # # # # # ','# # # # # # # # ','# # ','# # ']
            »  # join by newlines
               # OUTPUT: # # 
                         # # 
                         # # # # # # # # 
                         # # # # # # # # 
                         # # 
                         # #
— エミグナ
ソース
0

C＃、152バイト

n=>{var m="";foreach(int c in new[]{1,4,1})for(int i=0,j;i++<n;){for(j=0;j++<c;)m+=new System.Text.StringBuilder().Insert(0,"# ",n);m+="\n";}return m;};
— TheLethalCoder
ソース
0

SmileBASIC、57 50バイト

INPUT S
E$=("#"*S*3+CHR$(10))*S?E$SCROLL-S*2,-1?E$

説明：

INPUT SIZE
PART$=("#"*SIZE*3+CHR$(10))*S 'generate half of the pattern
PRINT PART$ 'print half the pattern
SCROLL SIZE*-2,-1 'scroll the text 2 squares right (and 1 character down)
PRINT PART$ 'print half the pattern again

最初のPRINTの後（サイズ= 2、@はカーソル位置）：

######
######

@

スクロール後：

    ######
    ######
@

2回目の印刷後：

    ######
    ######
######
######
@
— 12Me21
ソース
この場合、あなたは、スペースをスキップすることができます
— dkudriavtsevの
0

Common Lisp、83 81 79バイト

(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))

使用法：

(funcall #'(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))2)

出力：

# # # # # #
# # # # # #
    # # 
    # # 
    # # 
    # #       
    # # 
    # #

どのように機能しますか？

in format there is control string (inside "") and arguments after it
certain commands in string can use arguments (for example ~a displays argument)
~v{~} - takes argument and does commends inside {~} number of times 
                                      (number is given by argument)
       we can write text in loop body - it'll get displayed. Even if
       in loop body there are none commends to use arguments loop itself                 
       will consume one argument (it doesn't matter what it'll be -
       it doesn't seem to affect output)
~% - newline
~n* - jump n arguments forward (relative)
~n:* - jump n arguments backwards (relative)
~n@* - jump to argument n (global, counting from 0)

~v@{~v{# ~}~%~1@*~} <--- we make x rowns, 3x columns of string "# ". 
                         ~1@* is used during looping, it also means we end on argument 1. 
                         (second argument: (* x 3))
~v@{~vt~0@*~v{# ~}~%~} <--- we now make 3x rows, x columns of "(spaces)# "
                         ~vt - is used to move to accurate column. 
                         Here it takes argument (* x 2) - this is 
                         minimal number of columns to display. It uses
                         space as default character for missing characters
                         (when string inside <~> is shorter than min 
                         number of columns). I use it to make (* x 2) spaces, 
                         by giving it no text.
      ~0@* <--- after making spaces we have no new arguments, we go back to
                argument number zero - it is used to determine number of columns in our block

改善のためのアイデアを歓迎します。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.