La lettera E con E

19

Il tuo compito è quello di visualizzare la seguente lettera ASCII a forma di arte ASCII, dato cinque input.

Esempi:

Input: 7,2,+,|,-(Nota: non è necessario seguire questo formato di input esatto e, se non lo si utilizza, è necessario spiegare come funziona il proprio formato di input)

Spiegazione:

  • 7 larghezza totale, compresi i caratteri del bordo sinistro e destro.

  • 2 Numero di caratteri verticali.

  • + Il carattere che dovrebbe essere visualizzato ai bordi.

  • | Il carattere che dovrebbe essere visualizzato verticalmente tra i bordi.

  • - Il personaggio che dovrebbe essere visualizzato in orizzontale.

Output dell'esempio precedente:

+-----+ 
|
|
+-----+
|
|
+-----+

Altri esempi:

Ingresso: 7,2,@,|,-

Produzione:

@-----@
|
|
@-----@
|
|
@-----@

Ingresso: 7,2,+,|,#

Produzione:

+#####+
|
|
+#####+
|
|
+#####+

Ingresso: 8,3,+,|,#

Produzione:

+######+
|
|
|
+######+
|
|
|
+######+

Ingresso: 8,3,+,@,#

Produzione:

+######+
@
@
@
+######+
@
@
@
+######+

Ingresso: 9,4,^,$,!

Produzione:

^!!!!!!!^
$
$
$
$
^!!!!!!!^
$
$
$
$
^!!!!!!!^

Non sono consentite imbrogli e frodi standard.

Il tuo codice non deve stampare nulla su STDERR.

Il codice può accettare qualsiasi codifica di carattere che si sceglie come input, ma qualsiasi codifica di carattere scelta deve, come minimo, supportare tutti i 95 caratteri ASCII stampabili.

Il codice più breve, in byte, che completa correttamente questa sfida, è il codice vincente.

Classifica

Mostra snippet di codice

code-golf  ascii-art 
— Buffer over read
fonte
27
Non mi piace il caso speciale di "nessun input fornito". Secondo me, non aggiunge nulla alla sfida e complica molto per niente.
— Yytsi,
3
È il titolo perché potresti dare Ecome input e creare un Econ Es?
— trichoplax,
3
Nonostante ciò non mi piace, cosa significa veramente "nessun input"? La mia soluzione Floroid si bloccherà per il resto dell'eternità se non passi l'input. Affinché la mia soluzione sia competitiva, dovresti superare 5 zero e dovrei controllare se gli input sono zero e trattare di conseguenza ...? -1.
— Yytsi,
4
@TheBitByte Vedi il mio secondo commento per vedere cosa penso sia davvero sbagliato. Ora che l'hai modificato, +1.
— Yytsi,
1
@Kevin Yup. Stavo solo avendo un po 'di confusione con l'interpretazione di "nessun input". La stringa vuota non è uguale a "nessun input" nella mia mente. Ed ero così abituato a eseguire il codice all'interno di un interprete, sul quale aspetto letteralmente che venga immesso l'input, quindi è per questo che l'ho lanciato là fuori.
— Yytsi,

Risposte:

6

05AB1E , 16 14 byte

Í×s.ø©|`×`»D®»

Spiegazione

Í×                  # create a string of the correct nr of horizontal chars
  s.ø               # add the corner char on both sides
     ©              # save in register while keeping it on the stack
      |`            # push the remaining inputs to the top of the stack
        ×`          # push the correct nr of vertical chars on the stack
          »         # join on newline (joining the top vertical and horizontal sections)
           D        # duplicate this
            ®       # push the horizontal part again
             »      # join everything on newline

Provalo online!

Salvati 4 byte grazie ad Adnan.

— Emigna
fonte
1
Per curiosità, perché stai usando il ©registro: p?
— Adnan,
1
@Adnan: buona cattura! Stavo per farlo, ma alla fine non l'ho usato e ho dimenticato di rimuoverlo :)
— Emigna,
1
@muddyfish: leggere la spiegazione dalla domanda che parte non era ovvia, quindi l'ho persa. Grazie per avermi fatto sapere!
— Emigna,
1
C'è anche uno speciale comando Surround che funziona qui: Í×s.øU×S»X»D»Xr».
— Adnan,
2
@Adnan: hai ragione. Pensare bene! Non l'ho mai usato prima :)
— Emigna,
6

Python, 53 51 55 byte

lambda a,b,c,d,e:d.join("\n"*-~b).join([c+e*(a-2)+c]*3)

+4 byte grazie a @nimi

funzione lambda anonima, per chiamarla, scrivere f=prima di essa. Esempio:

>>> print f(4,1,"€","|","-")
€--€
|
€--€
|
€--€

alternativa, 53 byte

lambda a,b,c,d,e:((c+e*a+c+"\n"+(d+"\n")*b)*3)[:-b*2]

vecchia versione con il caso speciale senza input, 69 65 63 byte

yay a cambiare i requisiti durante la sfida ...

lambda a=1,b=1,(c,d,e)="+|-":d.join("\n"*-~b).join([c+e*a+c]*3)
— KarlKastor
fonte
2
Piccolo bug: il primo argomento ( 2nel tuo esempio) è la lunghezza totale della linea, inclusi gli angoli, quindi l'input giusto per la tua forma è f(4,1 ...).
— nimi,
@nimi grazie per il suggerimento. (+4 byte :() Il primo esempio di OP è un po 'confuso. (Alcune delle altre risposte hanno anche questo bug)
— KarlKastor,
4

C, 167 161 159 byte

Si. 

#define p putchar
i,j;g(a,c,e){p(c);for(i=2;i++<a;)p(e);p(c);p(10);}h(b,d){for(i=0;i++<b;){p(d);p(10);}}f(a,b,c,d,e){g(a,c,e);h(b,d);g(a,c,e);h(b,d);g(a,c,e);}

Provalo su Ideone, con alcuni casi di test

— betseg
fonte
2
mette ("") -> p ('\ n')? o anche p (10) se funzionerà
— RiaD
Come mi sono perso! Grazie, @RiaD.
— Betseg,
Inoltre, se avvii il ciclo con 2, salverai in più byte
— RiaD
3

Rubino, 54 45 42 byte

->x,y,c,v,h{[c+h*~-~-x+c+$/]*3*((v+$/)*y)}

È una funzione anonima che accetta le diverse parti dell'input come parametri separati e restituisce il risultato come una stringa completa.

Per esempio,

f=->x,y,c,v,h{[c+h*~-~-x+c+$/]*3*((v+$/)*y)}
puts f[6, 2, 'Ø', 'V', '>']

stampe 

Ø>>>>Ø
V
V
Ø>>>>Ø
V
V
Ø>>>>Ø
— daniero
fonte
3

Javascript (ES6), 64 byte

(h,v,e,V,H)=>(v=(h=e+H.repeat(h-2)+e)+`
${V}`.repeat(v)+`
`)+v+h

Esempio

let f =
(h,v,e,V,H)=>(v=(h=e+H.repeat(h-2)+e)+`
${V}`.repeat(v)+`
`)+v+h

console.log(f(8,3,'+','@','#'))
Espandi frammento

— Arnauld
fonte
Questo gestisce il caso speciale senza input?
— Conor O'Brien,
{ "message": "Script error.", "filename": "", "lineno": 0, "colno": 0 }quando eseguito in linea.
— noɥʇʎԀʎzɐɹƆ
@AgentCrazyPython - Esegui su IE? Non ha supporto per.repeat()
— Arnauld,
@Arnauld naw, safari
— noɥʇʎԀʎzɐɹƆ
oh, è ES6 ...
— noɥʇʎԀʎzɐɹƆ
3

R, 80 byte

Abbastanza ripetitivo:

function(h,v,a,b,c)cat(t<-c(a,rep(c,h),a,"\n"),d<-rep(c(b,"\n"),v),t,d,t,sep="")

Ungolfed:

function(h,v,a,b,c)

cat(t<-c(a,rep(c,h),a,"\n"),
    d<-rep(c(b,"\n"),v),
    t,d,t,
    sep="")
— Frédéric
fonte
2

Pyth, 19 byte

jP*3,++Jw*-E2wJj*Ew

Un programma che accetta input separati da nuova riga su STDIN del carattere d'angolo, numero di caratteri orizzontali, carattere orizzontale, numero di caratteri verticali e carattere verticale e stampa il risultato.

Provalo online

Come funziona

jP*3,++Jw*-E2wJj*Ew  Program.
       Jw            Get the corner character. Store in J
           E         Get the number of horizontal characters
          - 2        -2
         *   w       Get the horizontal character and repeat it that many times
      +              Add J at the beginning of that
     +         J     and at the end
                 E   Get the number of vertical characters
                * w  Get the vertical character and repeat it that many times
               j     Join the above on newlines
    ,                Construct a 2-element list from the horizontal and vertical strings
  *3                 Repeat it 3 times
 P                   Everything except the last element
j                    Join the above on newlines
                     Implicitly print
— TheBikingViking
fonte
2

MATLAB, 95 92 91 85 81 byte

Funzione MATLAB 'E'. (modifica: non funziona su Octave)

function a=e(n,m,c,h,v);a(1:n)=h;a=[c a c];a(2:m+1,1)=v;a=[a;a;a];a=a(1:3+2*m,:);

E non golfato:

function a=e(n,m,c,h,v); %Declare the function
a(1:n)=h;                %Initialise return with top line excluding the corners
a=[c a c];               %Then add corner pieces
a(2:m+1,1)=v;            %Next add the first vertical part
a=[a;a;a];               %Repeat three times vertically to get an E with a tail
a=a(1:3+2*m,:);          %And then lop off the tail

La funzione dovrebbe essere chiamata come:

e(5,2,'*','-','|')

Che restituirà:

+-----+
|      
|      
+-----+
|      
|      
+-----+

Questo probabilmente può essere semplificato un po ', continuerò a lavorarci su. Non mi piace avere l'intera dichiarazione di funzione per ottenere l'input, quindi vedrò se posso migliorarlo.

  • Salvato 3 byte semplificando la generazione della prima riga per creare prima la linea senza angoli e quindi aggiungere gli angoli poiché ciò riduce il numero di volte in cui è richiesta l'indicizzazione.

  • Un altro byte salvato iniziando dalla prima curva.

  • Altri 6 byte sostituendo la repmat(a,3,1)chiamata con [a;a;a].

  • Salvato 4 byte utilizzando asenza inizializzazione specifica (è già dichiarata nella dichiarazione di funzione) - grazie @LuisMendo

— Tom Carpenter
fonte
1
@LuisMendo interessante. Inizialmente l'avevo a=[c a c]inserito ma rimosso per ridurre le cose in quanto normalmente non è possibile indicizzare l'accesso a una variabile inesistente e crearla nel processo. Ho dimenticato che questa era una funzione, quindi aè già dichiarata nella dichiarazione della funzione come valore di ritorno. Grazie :)
— Tom Carpenter il
In effetti puoi farlo anche se non in una funzione: l'indicizzazione di una variabile inesistente la crea. Impara cose nuove ogni giorno.
— Tom Carpenter,
2

Perl, 40 + 1 (-n ) = 41 byte

Grazie a @Ton Hospel per aver salvato 14 byte e aver permesso al programma di funzionare con una voce maggiore di 10.

/.$/;$,=$/.<>x<>;say+($`.$&x(<>-2).$`)x3

È necessario -nnonché -E(o -M5.010) per eseguire. Per esempio : 

perl -nE '/.$/;$,=$/.<>x<>;say+($`.$&x(<>-2).$`)x3' <<< '^$
!
4
9'
— Dada
fonte
1
@TheBitByte Ok fantastico, è fatto, grazie.
— Dada,
2
Questo è già molto buono. Ma puoi giocare un po 'con il formato di input e anche risolvere il difetto che la sfida non dice che le ripetizioni sono < 10inserendo /(.)(.)/;$,=$' x<>;say+($1.$2x(<>-2).$1.$/)x3un file (dal momento che lo usa $') e chiamando con perl -M5.010 -n prog.pl <<< '^!S\n4\n9'(usa newline reali) che conta come 48 byte (2 extra handicap poiché non può essere combinato con -e)
— Ton Hospel
@TonHospel Grazie. Bene, non avevo nemmeno notato che questo non avrebbe funzionato con i numeri >10.. Ottimo lavoro con il formato di input, grazie.
— Dada,
Questo si sta avvicinando all'abuso della libertà di selezionare il formato di input, ma: perl -nE '/.$/;$,=$/.<>x<>;say+($`.$&x(<>-2).$`)x3' <<< '^$\n!\n4\n9'è di 41 byte (non più $') e si sbarazza anche della falsa nuova riga finale
— Ton Hospel
@TonHospel In effetti, ho trovato quella soluzione dopo il tuo primo suggerimento, ma non mi sentivo troppo a mio agio a causa del formato di input ... Dal momento che entrambi ci abbiamo pensato, ho cambiato la mia risposta, ma comunque, mi sento come è un po 'economico ...
— Dada,
2

Dyalog APL , 31 29 byte

Richiede carattere orizzontale, larghezza, carattere di giunzione, altezza, carattere verticale - in questo ordine.

h↓⊃⍪/3/⊂↑(⍞⍴⍨h←⎕),⊂⍞{∊⍺⍵⍺}⎕⍴⍞

⎕⍴⍞input-carattere orizzontale e ripetere i tempi di input-width ( ⍵ seguito)

⍞{... }input-junction-character che sarà ⍺ nella funzione ...

 ∊⍺⍵⍺ appiattire [[incrocio], [orizzontali], [incrocio]]

⊂ incapsulare in modo che possa far parte di un elenco

(... ),anteporre ...

 h←⎕ input-altezza

 ⍞⍴⍨ input-vertical-character e ripeterlo più volte

↑ trasforma l'elenco delle stringhe in una tabella di caratteri

⊂ incapsulare (quindi può essere ripetuto nel suo insieme)

3/ ripeterlo tre volte

╻  ╻  ╻
┗━ ┗━ ┗━

⍪/ concatenare i tre pezzi in verticale

╻
┣━
┣━
┗━

(anche questo li incapsula, quindi dobbiamo ...)

⊃ rimuovere l'incapsulamento

h↓rilascia la prima h (righe)

┏━
┣━
┗━

ProvaAPL online!

— Adamo
fonte
2

C, 130 byte

#define p putchar
#define E for(o=0;o++<O;p(10))p(S);
#define W for(p(P),D=0;D++<C-2;)p(_);p(P);p(10);
f(C,O,P,S,_,D,o){W E W E W}

Uso:

main(){f(7,2,'+','|','-');}

Produzione

+-----+
|
|
+-----+
|
|
+-----+
— Giacomo Garabello
fonte
Rimuovendo i punti definee virgola in se aggiungendoli come si f(C,O,P,S,_,D,o){W;E;W;E;W;}salva un byte.
— Betseg,
2

C #, 108 byte

(m,n,e,v,h)=>{string x=e+new string(h,m-2)+e+"\n",y=new string(v,n).Replace(v+"",v+"\n");return x+y+x+y+x;};

Funzione anonima che genera ogni linea orizzontale e verticale e crea l'output finale.

Funzione non golfata:

(m,n,e,v,h)=>
{
    string x = e + new string(h, m - 2) + e + "\n",
        y = new string(v, n).Replace(v + "", v + "\n");
    return x + y + x + y + x;
};

Programma completo con casi di test:

using System;

namespace LetterEWithoutE
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,int,char,char,char,string>f= (m,n,e,v,h)=>{string x=e+new string(h,m-2)+e+"\n",y=new string(v,n).Replace(v+"",v+"\n");return x+y+x+y+x;};

            Console.WriteLine(f(7,2,'+','|','-'));
            Console.WriteLine(f(7,2,'@','|','-'));
            Console.WriteLine(f(7,2,'@','|','#'));
            Console.WriteLine(f(8,3,'+','|','#'));
            Console.WriteLine(f(8,3,'+','@','#'));
            Console.WriteLine(f(9,4,'^','$','!'));
        }
    }
}
— adrianmp
fonte
2

MATL , 15 byte

Grazie a @muddyfish per una correzione

2-Y"yv!iiY"!yyy

Provalo online!

Spiegazione

I contenuti dello stack dopo ogni passaggio sono indicati per chiarezza, usando il primo esempio nella sfida.

2-    % Implicitly input number of repetitions of the char of the horizontal line.
      % Subtract 2
      %   STACK: 5
Y"    % Implicitly input char of the horizontal line. Apply run-length decoding
      %   STACK: '-----' (string)
y     % Implicitly input (from below) the char of the corners. Duplicate onto the top
      %   STACK: '+', '-----', '+'
v!    % Concatenate all the stack horizontally. We now have the horizontal line
      % including the corners
      %   STACK: '+-----+'
iiY"  % Take two inputs: char of the vertical line and number of repetitions
      %   STACK: '+-----+', '||'
!     % Transpose. This tranforms the string into a vertical char array, which
      % gives the vertical line
      %   STACK: '+-----+', ['|';'|'] (vertical char array)
y     % Duplicate from below: this pushes a new copy of the horizontal line
      % onto the top of the stack
      %   STACK: '+-----+', ['|';'|'], '+-----+'
y     % Duplicate from below: this pushes a new copy of the vertical line
      % onto the top of the stack
      %   STACK: '+-----+', ['|';'|'], '+-----+', ['|';'|'],
y     % Duplicate from below: this pushes a new copy of the horizontal line
      % onto the top of the stack
      %   STACK: '+-----+', ['|';'|'], '+-----+', ['|';'|'], '+-----+'
      % Implicitly display
— Luis Mendo
fonte
1

Bash + coreutils, 105 byte

printf -- "$3`printf -- "$4%.0s" $(seq $1)`$3`printf "\n$5%.0s" $(seq $2)`%.0s\n" {1..3}|sed -n 1,$(($2*2+3))p

Supponendo che il file all'interno del quale è memorizzato sia denominato A.sh, l'utilizzo sarebbe:

bash A.sh <Horizontal Segment Length w/out Edge Chars> <Vertical Segment Length> '<Left/Right Edge Char>' '<Char Between Edges>' '<Vertical Char>'

Il -- sono necessari, nel caso in cui uno degli ingressi di carattere sembra essere una -, eprintf apparentemente non gestisce trattini all'inizio di una stringa molto piacevole senza i doppi trattini.

Spiegazione

Supponendo che l'ingresso sia 5 2 + * |...

  1. $3printf -- "$4%.0s" $(seq $1)$3printf "\n$5%.0s" $(seq $2)

    Crea il primo segmento orizzontale e il segmento verticale tutti insieme. Ciò comporterebbe:

    +*****+
|
|

  2. printf -- "$3printf -- "$4%.0s" $(seq $1)$3printf "\n$5%.0s" $(seq $2)%.0s\n" {1..3}

    Ripeti la parte precedentemente creata 3più volte. Questo ora si traduce in:

    +*****+
|
|
+*****+
|
|
+*****+
|
|

  3. printf -- "$3printf -- "$4%.0s" $(seq $1)$3printf "\n$5%.0s" $(seq $2)%.0s\n" {1..3}|sed -n 1,$(($2*2+3))p

    Infine, reindirizzare l'output precedente per sedeliminare gli ultimi 2 segmenti di linea emettendo solo le prime <Vertical Segment Length>*2+3righe di E. Finalmente otteniamo ciò Eche vogliamo:

    +*****+
|
|
+*****+
|
|
+*****+
— R. Kap
fonte
1

PowerShell v2 +, 60 59 byte

param($a,$b,$c,$d,$e)(,($x="$c$($e*($a-2))$c")+,$d*$b)*2;$x

Accetta input come singoli argomenti della riga di comando. Costruisce la stringa orizzontale, la memorizza $xper usarla successivamente, quindi la forma in una matrice con l'operatore virgola ,. Esegue la concatenazione di array (ovvero aggiungendo elementi alla fine) di $dformulato in un array di $belementi. Questo, a sua volta, è formulato in una matrice di due elementi con un altro operatore virgola e viene lasciato sulla pipeline. Quindi, l'orizzontale $xviene lasciato sulla tubazione. Abusa della formattazione predefinita di Write-Outputper inserire una nuova riga tra gli elementi.

Esempio

PS C:\Tools\Scripts\golfing> .\the-letter-e-without-e.ps1 5 3 "z" "v" "d"
zdddz
v
v
v
zdddz
v
v
v
zdddz
— AdmBorkBork
fonte
1

Python 3, 60 byte

Una funzione

def p(a,b,c,d,e):q=c+e*(a-2)+c;return(q+'\n'+(d+'\n')*b)*2+q

Test Case

>>> print(p(8,2,'+','|','#'))
+######+
|
|
+######+
|
|
+######+
— Dignissimus - Spammy
fonte
hai 2 troppi trattini nell'output
— Blue
1

Brainf * ck, 147 byte

,>,>++++++++[<------<------>>-]<<-->>>,>,>,>+++>++>++++++++++<<[-<<<.<<<[->>+>>>.<<<<<]>>[-<<+>>]>.>>>>>.<[-<<<<<<[->+>>.>>>>.<<<<<<<]>[<+>-]]>>>>]

Riceve input da stdin come primi 5 caratteri inseriti. I primi due hanno 48 sottratti dal loro codice ASCII, quindi 0-9 si comportano come previsto. Per numeri> 9, aggiungi 48 al numero e usa il carattere corrispondente. Gli altri tre personaggi sono come specificato nella sfida.

Sono sicuro che non è la soluzione ottimale ma la vita è troppo breve per giocare a golf brainf * ck.

Con commenti:

[
    Input: number number corner vertical horizontal
    Numbers are single digits; add 48 and use the ASCII character corresponding
    to the number you want for numbers > 9.
    First number is the number of characters across. Second is the number down.

    Layout: {first number-2} {second number} {temp} {a} {b} {c}
]

,>,>++++++++[<------<------>>-]<<-->>>,>,>,
now we should have the first five cells with the specified layout
the 6th will hold 3 as a counter and the 7th 2 and the 8th 10 '\n'

>+++>++>++++++++++<<
[  while the 6th cell is not 0
    -
    <<<.    print corner
    <<<[->>+>>>.<<<<<]  print horizontal characters
    >>[-<<+>>]         copy temp back to 1st cell
    >.>>>>>.           print corner and newline
    <
    [ If the second counter is not zero
        -
        <<<<<<[->+>>.>>>>.<<<<<<<]  print vertical and newline n times
        >[<+>-]           copy temp back to 2nd cell
    ]
    >>>>
]

Esempio di esecuzione:

sean@SEANSBOX:~/Dropbox/Code/BF$ ./bf E.b
94^$!
^!!!!!!!^
$
$
$
$
^!!!!!!!^
$
$
$
$
^!!!!!!!^
— Sean McBane
fonte
1

PHP, 97 byte

list(,$w,$h,$c,$v,$r)=$argv;echo$b=str_pad($a=str_pad($c,++$w,$r)."$c\n",--$h*2+$w,"$v\n"),$b,$a;

nessun loop, solo builtin.

Corri con php -r '<code>' <parameters>.

— Titus
fonte
1

Java 7, 205 129 byte

String c(int w,int h,String a,char b,char c){String r=a,n="\n",l="";for(;w-->2;r+=c);r+=a+n;for(;h-->0;l+=b+n);return r+l+r+l+r;}

-76 byte grazie a uno sconosciuto anonimo.
PS: non andare a modificare i post di altre persone la prossima volta. Se hai qualcosa da golf, ti preghiamo di lasciarlo come commento, o se sta usando un approccio completamente diverso potresti dare la tua risposta. Comunque grazie per aver giocato a golf tutti questi byte, comunque - chiunque tu sia ..

Casi non testati e test:

Provalo qui.

class M {
    static String c(int w, int h, String a, char b, char c){
        String r = a,
               n = "\n",
               l = "";
        for(; w-- > 2; r += c);
        r += a+n;
        for( ;h-- > 0; l += b+n);
        return r+l+r+l+r;
    }

    public static void main(String[] a) {
        System.out.print(c(7, 2, "+", '|', '-'));
        System.out.print(c(9, 4, "?", '¡', '¿'));
    }
}

Produzione:

+-----+
|    
|    
+-----+
|    
|    
+-----+

?¿¿¿¿¿¿¿?
¡      
¡      
¡      
¡      
?¿¿¿¿¿¿¿?
¡      
¡      
¡      
¡      
?¿¿¿¿¿¿¿?
— Kevin Cruijssen
fonte
0

Racchetta 124 byte

(λ(w h a b c)(for((i 3))(display a)(for((i w))(display c))(display a)(when(< i 2)(displayln "")(for((j h))(displayln b)))))

Modulo più leggibile: 

(define(f w h a b c)
  (for((i 3))
    (display a)
    (for((i w))
      (display c))
    (display a)
    (when(< i 2)
      (displayln "")
      (for((j h))
        (displayln b)))))

test:

(f 7 2 "+" "|" "-" )

+-------+
|
|
+-------+
|
|
+-------+
— rnso
fonte
0

C ++, 121 byte

#import<string>
#import<iostream>
#define f(w,h,C,W,H){std::string s(w,W),t;s=C+s+C+"\n";for(int i=h;i--;)t=t+H+"\n";std::cout<<s+t+s+t+s;}

Ungolfed:

#import<string>
#import<iostream>
#define f(w,h,C,W,H){
    std::string s(w,W),t;  //define two strings, one empty, one with horizontal characters
    s = C+s+C+"\n";        //assemble a horizontal bar
    for(int i=h;i--;) 
        t=t+H+"\n";        //assemble a vertical bar
    std::cout<<s+t+s+t+s;  //print
}

In C ++ non è consentito dichiarare funzioni senza tipo come in C. Ma le macro che si comportano proprio come una funzione sono totalmente possibili. Si noti inoltre che la versione non modificata non verrà compilata fino a quando non si aggiunge un "\" a ciascuno ma all'ultima riga della macro. È possibile salvare due byte aggiuntivi rimuovendo {}, ma non è possibile utilizzare la macro due volte di seguito.

Uso:

int main() {
    f(4,2,'+','-','|')
    f(2,1,'@','#','i')
    return 0;
}

Produzione:

+----+
|
|
+----+
|
|
+----+
@##@
i
@##@
i
@##@

Provalo online

— Anedar
fonte
0

CJam , 23 byte

riri)N*r2*\r*\@r**a3*\*

Provalo online!

L'input è nell'ordine indicato, ma dovrebbe essere separato dallo spazio invece di usare una virgola. Alcune delle difficoltà sono quelle di ottenere l'input nell'ordine giusto per l' operazione di join* di CJam ; per il confronto la riorganizzazione dell'ingresso potrebbe salvare 4 byte .

Se gli ingressi sono duplicati, A B C D Eil programma funziona in questo modo:

ri     e# get A as integer
ri)N*  e# create B+1 newlines
r2*    e# create 2 Cs
\r*    e# join newlines with D (hereafter ND)
\@     e# bring A & Cs to the front
r*     e# create A Es
*      e# join, puts Es between Cs (hereafter CEC)
a3*    e# makes 3 copies of CEC strings
\*     e# join, puts NDs between CECs
— Linus
fonte
0

Lua (5.2), 144 byte

k,a,p,q=loadstring,arg,io.write,print l,d=k"for i=3,a[1]do p(a[5])end",k"for i=1,a[2]do q(a[4])end"b=a[3]p(b)l()q(b)d()p(b)l()q(b)d()p(b)l()p(b)

Provalo online! (Coding Ground)

Dovrebbe produrre qualcosa del genere in questo momento:

+@@@@@+
l
l
+@@@@@+
l
l
+@@@@@+

Proprio input: 7 2 + l @

È possibile modificare l'input nelle opzioni di compilazione project-> e lì modificare i valori, ogni valore come nell'esempio ma non separato da virgole ma da spazi.

— Licia
fonte
0

QBIC, 44 byte

::;;;X=A[q,a-2|X=X+C]X=X+A ?X[1,2|[1,b|?B]?X

Spiegazione

::;;;                 Get the input parameters, 2 numbers and 3 strings
X=A[q,a-2|X=X+C]X=X+A Build the horizontal string: The corner string, x-2 times the filler string and another corner
?X                    Print the horizontal string
[1,2|                 Do the next thing twice
[1,b|?B]?X            Print the right number of vertical strings, then the horizontal string.
— steenbergh
fonte
0

PHP, 94 byte

<?list($v,$h,$p,$d,$r)=$_GET[a];for($h++;$i<=2*$h;)echo$i++%$h?$d:str_pad($p,$v-1,$r).$p,"\n";

Input formatta un array nello stesso ordine della stringa suggerita

— Jörg Hülsermann
fonte
Se usi ,"\n"invece di ."\n", puoi rilasciare le parentesi per il ternario.
— Tito
for($h++;$i<=2*$h;)e $i++%$hsalva un altro byte.
— Tito
$v-1fornisce solo 3 caratteri orizzontali per [5,2,+,|,-]. Numero di caratteri orizzontali, esclusi i caratteri del bordo sinistro e destro
— Tito
@Titus giusto, ho il rollback della tua modifica. 5 orizzontale significa 3 caratteri con 2 spigoli = 5. Dai un'occhiata alla domanda. E per le altre idee Grazie
— Jörg Hülsermann,
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.