Konsantrik ASCII Altıgenler Çiz


15

Farklı pozitif tamsayılar kümesini alan ve eğik çizgiler, alt çizgiler, boşluklar ve satırsonlarından yapılan bu yan uzunluklara sahip eş merkezli altıgenlerin ASCII görüntüsünü veren mümkün olan en kısa programı yazın .

Https://mothereff.in/byte-counter tarafından sayılan bayt cinsinden en kısa program kazanır.

Örnekler

(Daha az satır aralığıyla daha iyi görünürler.)

Giriş ise 1çıkış, yan uzunluk 1 olan altıgen olmalıdır:

 __ 
/  \
\__/

Altıgenin üst ve altı için iki alt çizginin kullanıldığına dikkat edin, böylece daha iyi orantılı olur.

Genel olarak, N altıgen boyutu, her açılı tarafta N eğik çizgi ve hem üstte hem de altta 2 * N alt çizgi içerir.

Giriş 1 2çıktı ise , yan uzunluk 1 ve 2'ye sahip eş merkezli altıgenler olmalıdır:

  ____
 / __ \
/ /  \ \
\ \__/ /
 \____/

Giriş ise 1 3çıkış şöyle olmalıdır:

   ______
  /      \
 /   __   \
/   /  \   \
\   \__/   /
 \        /
  \______/

Giriş ise 1 3 2çıkış şöyle olmalıdır:

   ______
  / ____ \
 / / __ \ \
/ / /  \ \ \
\ \ \__/ / /
 \ \____/ /
  \______/

vb.

G / Ç Kuralları

Giriş, komut satırından veya stdin'den gelmelidir, ancak en uygun formatta olabilir.

Örneğin, bir komut satırı argümanı olarak her numarayı verebilir: > myprogram 1 3 2ya girmek için bir önceden biçimlendirilmiş liste olarak numaralar kullanıcıyı isteyebilir: [1, 3, 2].

Çıktı stdout'a veya dilinizin en yakın eşdeğerine gitmelidir.

Ek Kurallar

  • Girdi, her zaman bir sırayla değil , her zaman farklı pozitif tamsayılar kümesi olacaktır .
  • Çıktı ...
    • yanında /\ _ve satırsonu karakteri içermez .
    • sondaki boşluklar veya gereksiz önde gelen boşluklar yoktur.
    • harici önde gelen yeni satırlar içermez, ancak isteğe bağlı bir son satırsonu içerebilir .
  • Hiçbir şey girilmezse, hiçbir şey çıktılamaz (muhtemelen bir satırsonu hariç).
  • Eğer yardımcı olursa, giriş tamsayılarının 2 16'dan küçük olduğunu varsayabilirsiniz .

Does 1içteki veya dıştaki altıgen bakın?
NinjaBearMonkey

@hsl 1(veya herhangi bir sayı) kenar uzunluğu 1 olan altıgene karşılık gelir. (1 eğik çizgi = 2 alt çizginin olduğu uyarı ile.) Yani 1her zaman en içteki altıgene atıfta bulunacaktır.
Calvin'in Hobileri

Yanıtlar:


4

CJam, 148 116 109 bayt

Bu beklediğimden çok daha uzun sürdü. Başlangıçta, elmas zorluklarında olduğu gibi sol üst çeyreği tekrar tekrar inşa etmek ve gerisini aynadan almak istedim. Ancak alt çizgilerin üst ve alt yarı arasındaki ayna simetrisine uymadığını fark etmedim. Bu yüzden, sağ yarıyı yinelemeli olarak üretmek ve daha sonra sadece bir kez (solda) aynalamak için çoğunu tekrarlamam gerekiyordu.

S]2[l~]:(f#:+2bW%{_,2/~:T;{IT):T1<'\'/?S?S++}%__,2/=,2/I'_S?*_S+a@+\I'/S?S++a+}fI{)T)2*2$,-*1$W%"\/"_W%er@N}/

Burada test edin.

Fibonacci-esque örneği:

8 3 1 5 2
        ________________
       /                \
      /                  \
     /     __________     \
    /     /          \     \
   /     /   ______   \     \
  /     /   / ____ \   \     \
 /     /   / / __ \ \   \     \
/     /   / / /  \ \ \   \     \
\     \   \ \ \__/ / /   /     /
 \     \   \ \____/ /   /     /
  \     \   \______/   /     /
   \     \            /     /
    \     \__________/     /
     \                    /
      \                  /
       \________________/

Açıklama:

En üstte belirtildiği gibi, sağ yarıyı tekrarlayarak inşa ediyorum. Yani, başlangıçta ızgarada sadece tek bir alan var ve daha sonra olası her halka için, mevcut ızgarayı boşluklarda çevreliyorum veya yeni bir altıgen.

Bu yapıldıktan sonra, her satırı sola aynalar ve doğru hizalama için önde gelen boşluklarla doldururum. İşte kodun dökümü:

"Prepare the input and the grid:";
S]2[l~]:(f#:+2bW%
S]                "Push string with a space and wrap it in an array. This is the grid.";
  2               "Push a 2 for future use.";
   [l~]           "Read and evaluate the input, wrap it in an array.";
       :(         "Decrement each number by 1.";
         f#       "Map each number i to 2^i.";
           :+     "Sum them all up.";
             2b   "Get the base two representation.";
               W% "Reverse the array.":
"At this point, the stack has the proto-grid at the bottom, and an array of 1s and
 0s on top, which indicates for each hexagon if it's present or not.";

"Next is a for loop, which runs the block for each of those 0s and 1s, storing the
 actual value in I. This block adds the next semi-hexagon or spaces.";
{ ... }fI

"First, append two characters to all existing lines:";
_,2/~:T;{IT):T1<'\'/?S?S++}%
_                            "Duplicate the previous grid.";
 ,2/                         "Get its length, integer-divide by 2.";
    ~:T;                     "Get the bitwise complement and store it in T. Discard it.";
        {                 }% "Map this block onto each line of the grid.";
         I                   "Push the current hexagon flag for future use.";
          T):T               "Push T, increment, store the new value.";
              1<'\'/?        "If T is less than 1, push \, else push /.";
                     S?      "If the current flag is 0, replace by a space.";
                       S++   "Append a space and add it to the current line.";

"So for hexagons this appends '\ ' to the top half and '/ ' to the bottom half.
 For empty rings, it appends '  ' to all lines.";

"Now add a new line to the top and the bottom:"    
__,2/=,2/I'_S?*_S+a@+\I'/S?S++a+
__                               "Get two copies of the grid.";
  ,2/                            "Get its length, integer-divide by 2.";
     =                           "Get that line - this is always the middle line.";
      ,2/                        "Get ITS length, integer'divide by 2.";
         I'_S?*                  "Get a string of that many _ or spaces depending on the 
                                  current flag.";
               _S+               "Duplicate and a space.";
                  a@+            "Wrap in an array, pull up the grid, and prepend the line.";
                     \           "Swap with the other copy.";
                      I'/S?      "Choose between / and a space depending on the flag.";
                           S++   "Append a space, and add both characters to the line.";
                              a+ "Wrap in an array, and append line to the grid.";

"This is all. Rinse and repeat for all rings. The result will look something like this:

_____ 
     \ 
___   \ 
__ \   \ 
_ \ \   \ 
 \ \ \   \ 
_/ / /   / 
__/ /   / 
___/   / 
      / 
_____/ 

Note that there are still trailing spaces.";

"Finish up all lines. These will not be joined together any more, but simply left
 on the stack in pieces to printed out back-to-back at the end of the program.
 The following runs the given block for each line:";
{ ... } /

"This generates the necessary indentation, then mirrors the lines and puts them
 in the right order:"
)T)2*2$,-*\_W%"\/"_W%er\N
)                         "Slice off that trailing space, but leave it on the stack.";
 T                        "Remember T? That still has something like the the size of
                           the grid from the last iteration. In fact it's N-1, where
                           N is the largest visible hexagon. We can use that to figure
                           out how many spaces we need.";
  )2*                     "Increment and double.";
     2$                   "Copy the current line.";
       ,-                 "Subtract its length from 2*N.";
         *                "Repeat the space that often. This is our indentation.";
          \_              "Swap with the line and duplicate.";
            W%            "Reverse the line.";
              "\/"_W%er   "Replace slashes with backslashes and vice versa.";
                       \  "Swap with the original line.";
                        N "Push a line break.";

5

Python - 251, 240, 239228

l=input()+[0];m=max(l);A=abs;R=range
for j in R(2*m+1):print''.join([[' \\'[(A(j-i+m-1)/2.in l)*(2*m-i)/(j-m-.5)>1],'/'][(A(3*m-i-j)/2.in l)*(i-m-j+.5)/(j-.5-m)>0],'_'][(A(m-j)in l)*(A(2*m-i-.5)<A(m-j))]for i in R(4*m)).rstrip()

Alternatif yaklaşım (251):

l=input()+[0]
l.sort()
m=max(l)
M=2*m
s=[[' ']*m*4for j in' '*(M+1)]
for i in l:
 I=2*i;s[m-i][M-i:M+i]=s[m+i][M-i:M+i]='_'*I
 for k in range(i):K=k+1;s[m-k][M-I+k]=s[m+K][M+I-K]='/';s[m-k][M+I-K]=s[m+K][M-I+k]='\\'
for t in s:print''.join(t).rstrip()

3

APL (UTF-8'de 222 bayt)

(ve 133 karakter)

Bu soru özellikle UTF8 temsilindeki bayt miktarını istediğinden, aslında biraz daha çözülmek zorunda kaldım, böylece daha uzun ama UTF8 temsili daha kısadır. (Özellikle, işe gidip gelme operatörünün karakteri üç bayt (), ancak iki bayttır , böylece optimizasyon artık çalışmaz ve ayrıca atamayı çok pahalı hale getirir.)

{⎕←(~⌽∧\⌽⍵=' ')/⍵}¨↓⊃{⍵{⍺=' ':⍵⋄⍺}¨K↑(-.5×(K←⍴⍵)+⍴⍺)↑⍺}/{Z⍪⌽⊖Z←↑(⊂(⍵/' '),(2×⍵)/'-'),⍵{((-⍵)↑'/'),((2 4-.×⍵⍺)/' '),'\'}¨⌽⍳⍵}¨N[⍋N←,⎕]

Karakterlerde daha kısa olan (124) ancak UTF-8'de temsil edildiğinde daha fazla bayt kullanan önceki sürüm (230, ikinci sırada yer alacaktır):

M←' '⋄{⎕←⍵/⍨~⌽∧\⌽⍵=M}¨↓⊃{⍵{⍺=M:⍵⋄⍺}¨K↑⍺↑⍨-.5×(K←⍴⍵)+⍴⍺}/{Z⍪⊖⌽Z←↑(⊂(⍵/M),'-'/⍨2×⍵),⍵{('/'↑⍨-⍵),'\',⍨M/⍨2 4-.×⍵⍺}¨⌽⍳⍵}¨N[⍋N←,⎕]

Ölçek:

      {⎕←(~⌽∧\⌽⍵=' ')/⍵}¨↓⊃{⍵{⍺=' ':⍵⋄⍺}¨K↑(-.5×(K←⍴⍵)+⍴⍺)↑⍺}/{Z⍪⌽⊖Z←↑(⊂(⍵/' '),(2×⍵)/'-'),⍵{((-⍵)↑'/'),((2 4-.×⍵⍺)/' '),'\'}¨⌽⍳⍵}¨N[⍋N←,⎕]
⎕:
      3 1 5 2
     ----------
    /          \
   /   ------   \
  /   / ---- \   \
 /   / / -- \ \   \
/   / / /  \ \ \   \
\   \ \ \  / / /   /
 \   \ \ -- / /   /
  \   \ ---- /   /
   \   ------   /
    \          /
     ----------

Bu, üst ve alt taraflar için spesifikasyonları karşılamıyor gibi görünmektedir (kısa çizgiler değil, alt çizgiler olmalıdır) ve sonuç olarak alt taraflar için bir satır ile dengelenir.
Martin Ender

1

Perl 5, 352 ( anEbayraklar için 349 bayt + 3 )

Bu muhtemelen çok daha fazla golf olabilir.

@b=sort{$a>$b}@F;map{$_<$j||($j=$_)}@b;$k=++$j;for(;$j--;){$z=$"x$j;for($e=$k;--$e>$j;){$z.=$e~~@b?'/ ':'  '} $z.=($j~~@b?'_':$")x(2*$j);$z.=$_~~@b?' \\':'  'for($j+1..$k-1);say$z}for(0..$k-2){$z=$"x$_;for($e=$k;--$e>$_;){$z.=($e-$k+1?$":'').($e~~@b?'\\':$")}$z.=(($_+1)~~@b?'_':$")x(2*$_+2);$z.=($_~~@b?'/':$").($_-$k+1?$":'')for($_+1..$k-1);say$z}

Ungolfed:

# sort list of side lengths 
@b=sort{$a>$b}@F; 
# set $k and $j to max side length + 1
map{$_<$j||($j=$_)}@b;$k=++$j;
for(;$j--;){
  $z=$"x$j;
  for($e=$k;--$e>$j;){$z.=$e~~@b?'/ ':'  '}
  $z.=($j~~@b?'_':$")x(2*$j);
  $z.=$_~~@b?' \\':'  'for($j+1..$k-1);
  say$z
}
for(0..$k-2){
  $z=$"x$_;
  for($e=$k;--$e>$_;){$z.=($e-$k+1?$":'').($e~~@b?'\\':$")}
  $z.=(($_+1)~~@b?'_':$")x(2*$_+2);
  $z.=($_~~@b?'/':$").($_-$k+1?$":'')for($_+1..$k-1);
  say$z 
}

Örnek ( 1 5 3 14):

              ____________________________
             /                            \
            /                              \
           /                                \
          /                                  \
         /                                    \
        /                                      \
       /                                        \
      /                                          \
     /                 __________                 \
    /                 /          \                 \
   /                 /   ______   \                 \
  /                 /   /      \   \                 \
 /                 /   /   __   \   \                 \
/                 /   /   /  \   \   \                 \
\                 \   \   \__/   /   /                 /
 \                 \   \        /   /                 /
  \                 \   \______/   /                 /
   \                 \            /                 /
    \                 \__________/                 /
     \                                            /
      \                                          /
       \                                        /
        \                                      /
         \                                    /
          \                                  /
           \                                /
            \                              /
             \____________________________/

1

C # - 388 316 bayt

Düzenleme: Sondaki boşlukları yazdırmayı önledi ve bazı LINQ'larda attı

Komut satırı argümanlarını alan basit bir program. Maksimum altıgen boyutuyla tanımlanan bir dikdörtgenin her satırındaki olası her çizgiyi yineler ve satırları kırpmadan ve art arda yazdırmadan önce onu geçerli satıra ekler (isteğe bağlı yeni satır oluşturur).

Golf Kodu:

using System.Linq;class P{static void Main(string[]A){var I=A.Select(int.Parse);int m=I.Max(),i,j,y,x;for(j=m+1;j-->-m;){var r="";for(i=-2*m-1;++i<2*m-(y=j<0?-j-1:j);)r+="/\\_- "[(x=i<0?-i-1:i)>y&(x+=y)%2>0&x/2<m&&I.Contains(x/2+1)?(i^j)&1:x-y<(y=j<0?-j:j)&y<=m&I.Contains(y)?j<0?2:3:4];System.Console.WriteLine(r);}}}

Kod çözülmemiş kod:

using System.Linq; // all important

class P
{
    static void Main(string[]A)
    {
        var I=A.Select(int.Parse); // create int array

        for(int m=I.Max(),j=m+1,i,y,x;j-->-m;) // for each line...
        {
            var r=""; // current line

            for(i=-2*m-1;++i<2*m-(y=j<0?-j-1:j);) // for each char...
                r+="/\\_- "[// append something to the current line
                (x=i<0?-i-1:i)>y&(x+=y)%2>0&x/2<m&&I.Contains(x/2+1)?
                    (i^j)&1: // slashes as appropriate - I can't work out why this bit works, but it seems to
                x-y<(y=j<0?-j:j)&y<=m&I.Contains(y)?
                    j<0?2:3: // _ or - if required
                4]; // otherwise a space

            System.Console.WriteLine(r); // print current line
        }
    }
}

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.