Piramida Besar ASCII

25

pengantar

Ini 2600 SM dan orang-orang membangun piramida sekarang. Mereka sudah membuat dasar piramida tetapi tidak tahu bagaimana melanjutkannya. Jadi, mereka memanggil Anda untuk meminta bantuan.

Aturan membuat piramida cukup sederhana. Untuk layer di atas layer sebelumnya, yang perlu Anda lakukan adalah mengikuti panduan langkah demi langkah ini:

  1. Potong ujung-ujungnya dari lapisan sebelumnya.

  2. Di atas /karakter, harus ada \karakter dan sebaliknya. Ini berlaku untuk setiap karakter kecuali tepi.

  3. Karakter paling kiri selalu a /dan karakter paling kanan selalu \.

Mari kita ambil contoh dasar untuk piramida:

//\/\/\\

Kami memotong tepi, meninggalkan:

 /\/\/\

Kami mengubah garis miring ke depan dengan garis miring ke belakang dan sebaliknya:

 \/\/\/

Karakter paling kiri selalu a /dan karakter paling kanan selalu a \, jadi kami mengubahnya:

 //\/\\

Kami menempatkan layer ini pada layer sebelumnya:

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

Kami terus sampai bagian atas tercapai (yang terlihat seperti /\). Jadi, akhirnya kita dapatkan:

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

Ini yang Anda butuhkan untuk output.

Tugas

Diberi dasar piramida (dengan panjang lebih besar dari 3), menghasilkan piramida lengkap. Anda dapat dengan aman berasumsi bahwa karakter paling kiri adalah /dan karakter paling kanan adalah a \. Anda juga dapat mengasumsikan bahwa panjang dasar selalu sama . Penggunaan spasi tambahan diperbolehkan. Penggunaan ruang terdepan juga diperbolehkan, selama piramida tetap di tempatnya. Penggunaan 1 membuntuti dan 1 terkemuka baris diperbolehkan.

Uji kasus

Input: /\\\
Output:
 /\
/\\\

Input: //\\///\/\
Output:
    /\
   /\\\
  /\///\
 ///\\\/\
//\\///\/\

Input: /////////////\
Output:
      /\
     /\\\
    /////\
   /\\\\\\\
  /////////\
 /\\\\\\\\\\\ 
/////////////\

Ini adalah kode-golf , jadi pengiriman dengan jumlah byte paling sedikit menang!

code-golf  string  ascii-art 
— Adnan
sumber
Mengingatkan saya pada otomat seluler dasar . Mungkin itu akan membuat tantangan masa depan yang menarik?
— DoctorHeckle

Jawaban:

9

Jelly ,28 26 2524 byte

QṚ,QyḊḊṖṖj@QµÐĿµJ’⁶ẋ⁸żYṚ

-4 byte terima kasih kepada Dennis

Resep:

QṚ,QyḊḊṖṖj@QµÐĿµJ’⁶ẋ⁸żYṚ - one argument: input()
Q  Q       Q             - set of Left=input(): "/\"
 Ṛ                       - reverse Left: "\/"
  ,                      - Left-pair-Right: ["\/","/\"]
     ḊḊṖṖ                - dequeue Left twice, then pop twice: input()[2:-2]
    y                    - translate Right with mapping in Left: swaps internal slashes
         j@              - join Right with separator Left (@ swaps operands)
            µ  µ         - chain separators to form a 1,1,1 chain of chains
             ÐĿ          - loop while results are unique and collect them
                J        - yield [1,...,len(Left=input())]
                 ’       - decrement: [0,....len(input())-1]
                  ⁶      - " "
                   ẋ     - repeat Left Right times: ["", " ", ...]
                    ⁸ż   - zip Right and Left (⁸ is the link's Left argument):
                                ...pads the loop results
                      Y  - joins Left with line-feeds
                       Ṛ - reverse Left

(sajikan bersama limun, piramida-piramida itu dibuat untuk para pekerja yang haus)

Masak piramida tebas Anda sendiri di TryItOnline , atau coba semua campur sari yang disarankan OP

— Jonathan Allan
sumber
11

Pyth - 27 26 byte

Mengurangi oleh operasi yang diberikan dalam OP sampai berulang, yang merupakan kasus untuk baris kosong.

j_.e+*kdb.ujXtPtPNK"\/")_K

Test Suite .

— Maltysen
sumber
8

Python 2, 78 byte

f=lambda s,p='\n':(s[2:]and f('/%s\\'%s.translate('/\\'*128)[2:-2],p+' '))+p+s

Fungsi rekursif yang menghasilkan string. Setiap lapisan piramida ditambahkan ke panggilan rekursif dengan lapisan di atasnya. Awalan p, yang dimulai saat karakter baris baru mendapatkan satu ruang lagi untuk membuat segitiga. Lapisan berikutnya diproduksi dengan menukar garis miring, memotong dua simbol pertama dan terakhir, dan memasukkannya ke dalam garis miring kiri dan kanan.

Python 3 dapat menyimpan byte dengan melakukan *99di translate, karena persyaratan panjang-256 dijatuhkan.

— Tidak
sumber
Pintar menggunakan terjemahan, tetapi apakah kita tidak harus mencetak?
— Jonathan Allan
@ JonathanAllan Tidak secara default , Anda hanya perlu menampilkan seperti yang dikatakan tantangan.
— xnor
6

Haskell, 98 94 90 85 byte

q=init.tail
s '/'='\\'
s _='/'
t#""=t++"\\\n"
t#l=(' ':t)#(s<$>q l)++t++l#""
("/"#).q

Contoh penggunaan (catatan: dalam backslash Haskell dalam string literal harus dilepaskan \\):

*Main> putStr $ (("/"#).q) "//\\\\///\\/\\"
    /\
   /\\\
  /\///\
 ///\\\/\
//\\///\/\

Pendekatan perulangan sederhana: #melakukan pekerjaan dengan memetakan s, yang membalik /dan \, pada elemen dalam. Parameter tambahan tmelacak tingkat indentasi dan diperluas oleh spasi pada setiap panggilan rekursif.

Catatan: panggilan rekursif kedua dari #(-> l#"") melompat langsung ke case dasar dan hanya cara singkat untuk menambahkan l, \dan baris baru, yaitu menggantikan ++l++"\\\n".

Sunting: @xnatau disimpan 5 byte. Terima kasih!

— nimi
sumber
l++"\\\n"Sepertinya l#"".
— xnor
1
Cara yang menarik untuk menukar dua karakter dalam sebuah string sadalah [c|x<-s,c<-"ab",c/=x].
— xnor
@ xnor: Saya sudah mencoba banyak hal untuk menyingkirkan yang kedua ++"\\\n", tetapi melewatkan yang ini. Terima kasih!
— nimi
6

Python 3, 108 104 101 94 91 89 88 byte

b,f='\/';p=lambda t,n='\n':(t[2:]and p(f+''.join(map({f:b,b:f}.get,t[2:-2]))+b,n+' '))+n+t

-7 byte terima kasih kepada xnor (beri tahu saya bahwa kami tidak perlu mencetak!)
-3 byte terima kasih kepada xnor (mengambil deklarasi di luar deklarasi fungsi [d'oh])
-1 byte berkat Dennis (ganti f,b='/\\'dengan b,f='\/')

Uji di ideone . Catatan: input disesuaikan dengan garis miring terbalik ganda (bahkan string mentah tidak akan berfungsi jika berakhir dengan jumlah garis miring terbalik yang aneh).

— Jonathan Allan
sumber
Anda dapat bersama-sama mendeklarasikan di f,b='/\\'luar fungsi.
— xnor
@xnor Terima kasih, saya tidak bisa menghitung ^^
— Jonathan Allan
5

JavaScript (ES6), 91 86 byte

f=
(s,t=`
`)=>s[2]?f(`/${s.slice(2,-2).replace(/./g,c=>c>`/`?`/`:`\\`)}\\`,t+` `)+t+s:t+s
;
<input placeholder=Basis oninput=o.textContent=f(this.value)><pre id=o>
Luaskan cuplikan

Keluaran mencakup karakter baris baru terkemuka.

— Neil
sumber
3

Ruby, 80 byte

f=->s{s[-3]>?!&&f[" "+s.gsub(/^( *\/).|.(.$)?/){$1||$2||($&>?/??/:?\\)}]
puts s}

Tidak disatukan

f = ->s{
  s[-3] > ?! &&
    f[" " + s.gsub(/^( *\/).|.(.$)?/) {
      $1 || $2 || ($& > ?/ ? ?/ : ?\\)
    }]
  puts s
}

Lihat di ideone: http://ideone.com/HN0l0Y

— Jordan
sumber
f
— salahku
3

Batch, 137 byte

@echo off
if %1==/\ goto g
set s=%1
set s=\%s:~2,-2%/
set s=%s:/=-%
set s=%s:\=/%
set s=%s:-=\%
call %0 %s% "%~2 "
:g
echo %~2%1

Mudah digunakan %~2dan %1berarti saya menghindari harus menghabiskan byte setlocal. Penjelasan: Karena Batch tidak akan melakukan penggantian pada string kosong, kita harus mengatur lapisan berikutnya dengan tepi "salah", yang kemudian akan dikoreksi sebagai bagian dari penggantian string.

— Neil
sumber
2

BASH (sed + sort) 71 66 Bytes

sed -rne':l;p;y|\\|1|;y|/|\\|;y|1|/|;th;:h;s|\\.(.*)./| /\1\\|;tl'|sort   
sed -rne':l;p;y|\\/|1\\|;y|1|/|;th;:h;s|\\.(.*)./| /\1\\|;tl'|sort

input berasal dari stdin.
Contoh:

echo '//\\' |sed -rne':l;p;y|\\|1|;y|/|\\|;y|1|/|;th;:h;s|\\.(.*)./| /\1\\|;tl'|sort

 /\
/\\\

Penjelasan:
-n- tekan cetak otomatis
:l- dan tlcabang kembali ke awal jika baris ini adalah sesuatu selain /\
p - cetak baris ini
y|\\/|1\\|;y|1|/|- ganti \dengan 1, /dengan \, dan kemudian 1dengan /
th;:h- tes dan lompati tempat yang sama, sehingga hanya penggantian berikutnya yang diuji. nanti
s|\\.(.*)./| /\1\\|- ganti dua bagian luar yang dipotong pada masing-masing sisi dengan {space}/dan \
sort- spaceada sebelum /jadi ini menempatkan semuanya dalam urutan yang benar

— Riley
sumber
2

05AB1E, 42 38 36 byte

Dg;<FÐgÍ©£R®ÍN-£„/\‡'/ðN>׫«R'\«}r»

Cobalah online!

Penjelasan:

# Read the input to the stack, loop for 0 .. len(input) / 2 - 1
Dg;<F
# Save the layer by pushing a copy on the stack, then push
# len(layer) - 2 to both the top of the stack and register_c
     ÐgÍ©
# a = pop(); b = pop(); push(b[0:a].reverse())
# This removes the last 2 characters and reverses
         £R
# push(register_c - 2 - N)
           ®ÍN-
# a = pop(); b = pop(); push(b[0:a])
# This removes the leading spaces and the first two slashes
               £
# Push "/\" and "\/" to the stack.
                 „/\Â
# Transliterate the slashes
                     ‡
# Add N+1 spaces and a / to the end of the (reversed) current layer
                      '/ðN>׫«
# Reverse the layer and add a \ to the end.
                              R'\«
# End the loop
                                  }
# Reverse the stack and join it with newlines. It is implicitly printed.
                                   r»

(Terima kasih kepada Emigna karena menunjukkan itu DD -> Ðdan DR -> Â).

— ruds
sumber
Dg;GDðK¦¦¨¨„/\‡'\«R'/«ðN׫R}r»menghemat 7 byte.
— Emigna
Itu terlihat cukup berbeda bagi saya sehingga saya pikir Anda harus menambahkan jawaban Anda sendiri :).
— ruds
1

Pergi, 300 276 byte

package main
import(."regexp";."os")
func p(b string)string{
s:=MustCompile(`((\s*.)(\S*)(\S))`).FindStringSubmatch(b)
if s[3]!=""{r:=""
for _,c:=range s[3][1:len(s[3])-1]{r+=`\/`[c/64:c/46]}
return p(" "+s[2]+r+`\`)+s[1]+"\n"}
return s[1]+"\n"}
func main(){print(p(Args[1]))}

Versi panjang:

package main

import (
    "regexp"
    "os"
)

func pyramid(base string) string {
    m := regexp.MustCompile(`^((\s*\S)(\S*)(\S))\s*`).FindStringSubmatch(base)
    if len(m[3]) > 0 {
        reversed := ""
        for _, c := range m[3][1:len(m[3]) - 1] {
            if c == '/' {
                reversed += `\`
            } else {
                reversed += `/`
            }
        }
        return pyramid(" " + m[2] + reversed + m[4]) + m[1] + "\n"
    }
    return m[1] + "\n"
}

func main() {
    print(pyramid(os.Args[1]))
}
— Roland Illig
sumber
import(."regexp";."os")menghemat 2 byte
— Sefa
@Sefa Terima kasih, saya memeras 22 byte dari itu.
— Roland Illig
1

Perl, 53 52 byte

Termasuk +1 untuk -p

Jalankan dengan input pada STDIN, mis

./pyramid.pl <<< '//\\///\/\'

pyramid.pl:

#!/usr/bin/perl -p
s%^( *)/.(.*)..%"$1 \\$2/
"=~y|\\/|/\\|r.$&%e&&redo
— Ton Hospel
sumber
1

05AB1E , 31 byte

Dg;GDðK¦¦¨¨„/\‡'\«R'/«ðN׫R}r»

Penjelasan

Dg;G                        }    # for N in [1..len(input)/2-1]
    D                            # make a copy of previous layer
     ðK                          # remove all spaces
       ¦¦¨¨                      # remove first 2 and last 2 chars
           „/\‡                 # replace '/' with '\' and vice versa
                '\«              # add a backslash at the end
                   R             # reverse
                    '/«          # ad a slash at the end
                       ðN׫      # add N spaces
                           R     # reverse back
                             r»  # reverse stack and join on newline
                                 # implicitly print

Cobalah online

— Emigna
sumber
1

> <> , 186 179 175 171 byte

0&v &+1&<
  >i:0)?^~&2,:&v
v'/'~v?:-1<  }0<
o    >84*o^-$;?=@:&:&}:~<
\&::&{:@+$}1+[{l1-$-2*:&1+{
>}1-:?!v$:l2%?!vo
^o'/'v?~e  (*5a<
^o'\'< &   >~]a'\'oo{1+:^
  {$1- >:?!^

oooh man ini pasti jawaban terbesar saya> <>.

Mungkin masih ada beberapa golf yang harus dilakukan (area bawah cukup boros)

Cobalah online

— torcado
sumber
0

Powershell, 142 byte

function s($s){if($s.Trim()-eq'/\'){return $s}
$n=$s-replace'\\','#'-replace'/','\'-replace'#','/'-replace'\\.(.*)./',' /$1\'
(s($n))+"`n$s"
}
— Oliver Rahner
sumber
0

C #, 250 byte

s=>{int j=s.Length/2,i=0;var l=new string[j];l[j-1]=s;while(++i<j){var n=l[j-i].Trim().Substring(1,l[j-i].Trim().Length-2);l[j-i-1]=new string(' ',i)+"/"+n.Replace("/","#").Replace(@"\","/").Replace("#",@"\").Substring(1,n.Length-2)+@"\";}return l;};

Pasti bisa bermain golf lebih jauh tetapi otak saya mati sehingga saya memutuskan untuk membiarkannya seperti saat ini.

— TheLethalCoder
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.