La grande piramide di ASCII

25

introduzione

È il 2600 a.C. e la gente sta costruendo piramidi ora. Hanno già creato la base della piramide ma non sanno come continuare. Quindi ti hanno chiamato per chiedere aiuto.

Le regole per creare una piramide sono abbastanza semplici. Per il livello sopra il livello precedente, tutto ciò che devi fare è seguire questa guida manuale passo-passo:

  1. Taglia i bordi dal livello precedente.

  2. Sopra il /personaggio, ci deve essere un \personaggio e viceversa. Questo vale per ogni personaggio tranne i bordi.

  3. Il personaggio più a sinistra è sempre un /e il personaggio più a destra è sempre \.

Facciamo un esempio di una base per una piramide:

//\/\/\\

Tagliamo i bordi, lasciando:

 /\/\/\

Modifichiamo le barre in avanti con barre all'indietro e viceversa:

 \/\/\/

Il personaggio più a sinistra è sempre un /e il personaggio più a destra è sempre un \, quindi cambiamo che:

 //\/\\

Posizioniamo questo livello sul livello precedente:

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

Continuiamo fino a raggiungere la cima (che sembra /\). Quindi, alla fine otteniamo:

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

Questo è ciò che devi produrre.

L'obiettivo

Data la base di una piramide (con una lunghezza maggiore di 3), produce l'intera piramide. Puoi tranquillamente supporre che il carattere più a sinistra sia /e il carattere più a destra sia a \. Puoi anche supporre che la lunghezza della base sia sempre pari . È consentito l' uso di spazi finali . È consentito anche l' uso di spazi iniziali, purché la piramide rimanga in posizione. È consentito l'uso di 1 trailing e 1 newline principali .

Casi test

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

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

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

Questo è code-golf , quindi vince l'invio con il minor numero di byte!

code-golf  string  ascii-art 
— Adnan
fonte
Mi ricorda un automa cellulare elementare . Forse sarebbe una sfida futura interessante?
— DoctorHeckle,

Risposte:

9

Jelly ,28 26 2524 byte

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

-4 byte grazie a Dennis

Ricetta:

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

(servire con la limonata, quelle piramidi sono per i lavoratori assetati)

Prepara la tua piramide slash su TryItOnline o prova tutti gli assaggiatori suggeriti dal PO

— Jonathan Allan
fonte
11

Pyth - 27 26 byte

Riduce dell'operazione indicata nell'OP fino a quando non si ripete, come nel caso della riga vuota.

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

Test Suite .

— Maltysen
fonte
8

Python 2, 78 byte

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

Una funzione ricorsiva che genera una stringa. Ogni livello della piramide viene aggiunto alla chiamata ricorsiva con il livello sopra di essa. Il prefissop , che inizia come un carattere di nuova riga, guadagna un ulteriore spazio per creare il triangolo. Il livello successivo viene prodotto scambiando le barre, tagliando il primo e gli ultimi due simboli e inserendolo all'interno di una barra sinistra e destra.

Python 3 può salvare un byte facendo *99in translate, come il requisito di lunghezza-256 è stata abbandonata.

— XNOR
fonte
Intelligente usando la traduzione, ma non è necessario stampare?
— Jonathan Allan,
@JonathanAllan Non di default , devi solo produrre come dice la sfida.
— 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

Esempio di utilizzo (nota: in Haskell le barre rovesciate all'interno di stringhe letterali devono essere sfuggite \\):

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

Semplice approccio recurse: #fa il lavoro di mappatura s, che ribalta l' /e \, sugli elementi interni. Il parametro aggiuntivo ttiene traccia del livello di rientro ed è espanso di uno spazio su ogni chiamata ricorsiva.

Nota: la seconda chiamata ricorsiva di #(-> l#"") passa direttamente al caso base ed è solo un modo breve per aggiungere l, \e una nuova riga, ovvero sostituisce++l++"\\\n" .

Modifica: @xnor ha salvato 5 byte. Grazie!

— Nome del modello
fonte
l++"\\\n"sembra l#"".
— xnor
1
Un modo interessante per scambiare due caratteri in una stringa sè [c|x<-s,c<-"ab",c/=x].
— xnor
@xnor: ho provato molte cose per sbarazzarmi del secondo ++"\\\n", ma ho perso questo. Grazie!
— 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 grazie a xnor (facendomi sapere che non è necessario stampare!)
-3 byte grazie a xnor (prendendo una dichiarazione al di fuori della dichiarazione di funzione [d'oh])
-1 byte grazie a Dennis (sostituisci f,b='/\\'con b,f='\/')

Provalo su ideone . Nota: input regolato per una doppia barra rovesciata (anche le stringhe non elaborate non funzioneranno se terminano in un numero dispari di barre rovesciate).

— Jonathan Allan
fonte
È possibile dichiarare congiuntamente f,b='/\\'al di fuori della funzione.
— xnor
@xnor Grazie, non posso contare ^^
— 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>
Espandi frammento

L'output include un carattere di nuova riga iniziale.

— Neil
fonte
3

Rubino, 80 byte

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

Ungolfed

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

Guardalo su ideone: http://ideone.com/HN0l0Y

— Giordania
fonte
mio male, non l'ho visto fnel corpo
— Cyoce,
3

Lotto, 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

Convenientemente il mio uso %~2e %1significa che evito di dover spendere byte setlocal. Spiegazione: Poiché Batch non eseguirà sostituzioni sulla stringa vuota, dobbiamo impostare il livello successivo con i bordi "errati", che verranno quindi corretti come parte delle sostituzioni di stringa.

— Neil
fonte
2

BASH (sed + sort) 71 66 byte

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

l'input proviene da stdin.
Esempio:

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

 /\
/\\\

Spiegazione:
-n- sopprimere la stampa automatica
:l- e tlricominciare dall'inizio se questa riga era diversa da /\
p - stampare questa riga
y|\\/|1\\|;y|1|/|- sostituire \con 1, /con \e quindi 1con /
th;:h- testare e saltare nello stesso punto, in modo che venga testata solo la sostituzione successiva più tardi
s|\\.(.*)./| /\1\\|- sostituisci i due esterni tagliati da ciascun lato con{space}/ e \
sort- spaceviene prima, /quindi questo mette tutto nel giusto ordine

— Riley
fonte
2

05AB1E, 42 38 36 byte

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

Provalo online!

Spiegazione:

# 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»

(Grazie a Emigna per averlo sottolineato DD -> Ðe DR -> Â).

— ruds
fonte
Dg;GDðK¦¦¨¨„/\‡'\«R'/«ðN׫R}r»salva 7 byte.
— Emigna,
Mi sembra abbastanza diverso da pensare che dovresti aggiungere la tua risposta :).
— ruds
1

Vai, 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]))}

Versione lunga:

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
fonte
import(."regexp";."os")salva 2 byte
— Sefa il
@Sefa Grazie, ne ho spremuto altri 22 byte.
— Roland Illig,
1

Perl, 53 52 byte

Include +1 per -p

Esegui con l'ingresso su STDIN, ad es

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

pyramid.pl:

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

05AB1E , 31 byte

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

Spiegazione

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

Provalo online

— Emigna
fonte
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 amico questa è sicuramente la mia più grande> <> risposta ancora.

Probabilmente c'è ancora del golf da fare (l'area inferiore è piuttosto dispendiosa)

Provalo online

— torcado
fonte
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
fonte
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;};

Posso sicuramente continuare a giocare a golf, ma il mio cervello è morto, quindi ho deciso di lasciarlo così com'è per il momento.

— TheLethalCoder
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.