Stendi il tappeto

40

Ispirato da questa domanda SO .

Sfida:

Ingresso:

  • Una stringa S
  • Un personaggioc

Produzione:

Crea un'arte ASCII a forma di diamante della stringa in tutte e quattro le direzioni, con il primo carattere della stringa al centro e verso l'esterno. Che si trova all'interno di un tappeto quadrato di arte ASCII, con il personaggio come riempitivo. Questo può sembrare piuttosto vago, quindi ecco un esempio:

Ingresso: = , = Uscita:Sstringc.

..........g..........
........g.n.g........
......g.n.i.n.g......
....g.n.i.r.i.n.g....
..g.n.i.r.t.r.i.n.g..
g.n.i.r.t.s.t.r.i.n.g
..g.n.i.r.t.r.i.n.g..
....g.n.i.r.i.n.g....
......g.n.i.n.g......
........g.n.g........
..........g..........

Regole della sfida:

  • La stringa di input può anche essere un elenco di caratteri
  • L'output può anche essere un elenco di linee di stringa o matrice di caratteri
  • La stringa di input e il carattere sono garantiti come non vuoti
  • Si garantisce che la stringa non contenga il carattere
  • Sia la stringa che il carattere saranno solo ASCII stampabili (intervallo unicode [32.126], spazio da "" a incluso tilde "~")

Regole generali:

  • Questo è code-golf , quindi vince la risposta più breve in byte.
    Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
  • Per la tua risposta valgono regole standard con regole I / O predefinite , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
  • Sono vietate le scappatoie predefinite .
  • Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
  • Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi test:

Ingresso: = , = Uscita:S11111c=0

00000000100000000
00000010101000000
00001010101010000
00101010101010100
10101010101010101
00101010101010100
00001010101010000
00000010101000000
00000000100000000

Ingresso: = , = Uscita:Sc12345ABCDEFc#

####################F####################
##################F#E#F##################
################F#E#D#E#F################
##############F#E#D#C#D#E#F##############
############F#E#D#C#B#C#D#E#F############
##########F#E#D#C#B#A#B#C#D#E#F##########
########F#E#D#C#B#A#5#A#B#C#D#E#F########
######F#E#D#C#B#A#5#4#5#A#B#C#D#E#F######
####F#E#D#C#B#A#5#4#3#4#5#A#B#C#D#E#F####
##F#E#D#C#B#A#5#4#3#2#3#4#5#A#B#C#D#E#F##
F#E#D#C#B#A#5#4#3#2#1#2#3#4#5#A#B#C#D#E#F
##F#E#D#C#B#A#5#4#3#2#3#4#5#A#B#C#D#E#F##
####F#E#D#C#B#A#5#4#3#4#5#A#B#C#D#E#F####
######F#E#D#C#B#A#5#4#5#A#B#C#D#E#F######
########F#E#D#C#B#A#5#A#B#C#D#E#F########
##########F#E#D#C#B#A#B#C#D#E#F##########
############F#E#D#C#B#C#D#E#F############
##############F#E#D#C#D#E#F##############
################F#E#D#E#F################
##################F#E#F##################
####################F####################

Ingresso: S = @+-|-o-|-O, c = :
Uscita:

::::::::::::::::::O::::::::::::::::::
::::::::::::::::O:-:O::::::::::::::::
::::::::::::::O:-:|:-:O::::::::::::::
::::::::::::O:-:|:-:|:-:O::::::::::::
::::::::::O:-:|:-:o:-:|:-:O::::::::::
::::::::O:-:|:-:o:-:o:-:|:-:O::::::::
::::::O:-:|:-:o:-:|:-:o:-:|:-:O::::::
::::O:-:|:-:o:-:|:-:|:-:o:-:|:-:O::::
::O:-:|:-:o:-:|:-:+:-:|:-:o:-:|:-:O::
O:-:|:-:o:-:|:-:+:@:+:-:|:-:o:-:|:-:O
::O:-:|:-:o:-:|:-:+:-:|:-:o:-:|:-:O::
::::O:-:|:-:o:-:|:-:|:-:o:-:|:-:O::::
::::::O:-:|:-:o:-:|:-:o:-:|:-:O::::::
::::::::O:-:|:-:o:-:o:-:|:-:O::::::::
::::::::::O:-:|:-:o:-:|:-:O::::::::::
::::::::::::O:-:|:-:|:-:O::::::::::::
::::::::::::::O:-:|:-:O::::::::::::::
::::::::::::::::O:-:O::::::::::::::::
::::::::::::::::::O::::::::::::::::::

Ingresso: S = AB, c = c
Uscita:

ccBcc
BcAcB
ccBcc

Ingresso: S = ~, c = X
Uscita:

~

Ingresso: S = /\^/\, c = X
Uscita:

XXXXXXXX\XXXXXXXX
XXXXXX\X/X\XXXXXX
XXXX\X/X^X/X\XXXX
XX\X/X^X\X^X/X\XX
\X/X^X\X/X\X^X/X\
XX\X/X^X\X^X/X\XX
XXXX\X/X^X/X\XXXX
XXXXXX\X/X\XXXXXX
XXXXXXXX\XXXXXXXX
code-golf  string  ascii-art 
— Kevin Cruijssen
fonte
La stringa può contenere spazi?
— Emigna il
1
@Emigna Sì, tutti gli ASCII stampabili (intervallo unicode [32.126]) sono caratteri di input validi.
— Kevin Cruijssen il
1
Questo diventa meraviglioso per il debug se usi personaggi che sembrano visivamente come un singolo personaggio, ad es ()()().
— Filip Haglund,
Cosa dovrebbe succedere se $ s $ è vuoto?
— Solomon Ucko,
@SolomonUcko Dalla sezione delle regole: "La stringa di input e il carattere sono garantiti come non vuoti " :)
— Kevin Cruijssen,

Risposte:

6

R , 118 95 92 byte

function(a,d,n=length(a),I=c(n:1,1:n)[-n])for(i in I-1)write(c(a,d)[pmin(I+i,n+1)],1,n*2,,d)

Provalo online!

Grazie a:

  • Giuseppe per aver corretto un errore e un golf
  • Aaron Hayman per 22 byte di golf
— Kirill L.
fonte
Immagino di dover abbandonare la mia avversione per i forloop in R, almeno per il golf.
— Aaron Hayman,
@Giuseppe, grazie, non dovrei essere così pigro per l'inclusione di casi di test extra!
— Kirill L.
1
Questo per 98 sembra più vicino alla tua soluzione della mia Provalo online!
— Aaron Hayman,
1
puoi toglierne altri due con un po 'di riarrangiamento: provalo online!
— Aaron Hayman,
1
@AaronHayman oppure questo 92 byter combina la pminlogica con il riarrangiamento :-)
— Giuseppe,
5

R , una brutta versione da 118 byte

Lasciando che l'input sia un vettore di singoli caratteri e produca una matrice invece di stampare una bella arte ASCII.

function(s,C,l=length(s),L=4*l-3,k=2*l-1,y=abs(rep(1:k,L)-l)+abs(rep(1:L,e=k)-k)/2+1)matrix(ifelse(y%%1|y>l,C,s[y]),k)

Provalo online!

R , 161 157 byte

salvato 4 byte utilizzando ifelse invece di modificare in modo condizionale y 

function(S,C,l=nchar(S),L=4*l-3,k=2*l-1,y=abs(rep(1:L,k)-k)/2+abs(rep(1:k,e=L)-l)+1)cat(rbind(matrix(ifelse(y%%1|y>l,C,el(strsplit(S,''))[y]),L),'
'),sep='')

Provalo online!

non golfato e commentato

function(S,C){
    s=el(strsplit(S,''))
    l=nchar(S)
    L=4*l-3
    k=2*l-1
    y=abs(rep(1:L,k)-k)/2+abs(rep(1:k,e=L)-l)+1 # distance from centre
    y[!!y%%1]=l+1  # set non integers to one more than length of string
    y[y>l]=l+1     # set number beyond length of string to one more than length of string
    M = rbind(matrix(c(s,C)[y],L),'\n') # build matrix and add line returns
    cat(M,sep='') # print the matrix as a string
}

hmmm, sembra la risposta più lunga finora!

— Aaron Hayman
fonte
Oh caro, avrei dovuto esaminare meglio la domanda
— Aaron Hayman,
1
@KevinCruijssen L'ho risolto ora
— Aaron Hayman il
1
per +15 byte, puoi fare la tua brutta risposta ascii-art: provala online!
— Giuseppe
4

05AB1E , 15 11 byte

.sûsζøsýí€û

Provalo online! o come una suite di test

Spiegazione

.s            # push suffixes of input
  û           # palendromize this list
   sζ         # transpose using the second input as filler
     ø        # transpose back
      sý      # merge each on the second input
        í     # reverse each row
         €û   # palendromize each row
— Emigna
fonte
1
@KevinCruijssen: Sì. Fortunatamente non è costato alcun byte per risolverlo. Sento comunque che dovrebbe esserci un modo migliore per farlo, quindi continuerò a cercare.
— Emigna il
"L' output può anche essere un elenco di stringhe o matrici di caratteri ", quindi puoi spostare »il piè di pagina. :)
— Kevin Cruijssen il
@KevinCruijssen Ah giusto. Ho dato un'occhiata a quella parte. Grazie :)
— Emigna il
4

J , 35 34 33 byte

,{~1j1(}:@#"1{:(<*-)1-|+/|)i:@-&#

Provalo online!

Da destra a sinistra:
-&#lunghezza di c meno la lunghezza di S
i: Intervallo da negativo n a n
1-|+/| valore assoluto, somma esterno con valore assoluto, sottrarre 1
{: (<*-)Confrontare la matrice con la fine della gamma (la -&#), 0 per meno di o uguale, 1 altrimenti. Sottrarre anche la matrice dalla fine dell'intervallo. Moltiplicare insieme. La doppia sottrazione salva un byte e dà qualcosa del genere

 0  0 _1  0  0
 0 _1 _2 _1  0
_1 _2 _3 _2 _1
 0 _1 _2 _1  0
 0  0 _1  0  0

Gli indici negativi iniziano da -1 come in Python. L'unica cosa rimasta è inserire le colonne di zero.

1j1( #"1per ogni riga, ripetere ogni elemento 1 volta e pad con uno 0
  }:@quindi rilasciare l'ultimo (zero)
,{~concat cS

Mille grazie a Galen Ivanov per l'algoritmo.

— FrownyFrog
fonte
Ti dispiacerebbe aggiungere una spiegazione? Non ho molta familiarità con J.
— Kevin Cruijssen il
4

K (ngn / k) , 38 byte

{1_',/'y,''2{+x,1_|x}/(#x)'1_,/+y,'|x}

Provalo online!

{ }funzione con argomenti x(la stringa s ) e y(il carattere c )

|x inverso x

y,'anteporre ya ciascuno

+ trasporre

,/ concat

1_ rilascia il primo carattere

a questo punto abbiamo una stringa di xistanze length ( ) yseguite dai caratteri dix

#x lunghezza di x

(#x)' finestra scorrevole di tanti caratteri consecutivi

2{ }/ fare due volte

+x,1_|xunire xcon l'inverso xsenza il suo primo elemento e trasporre

y,''anteporre ya ciascuno di essi

,/' concatene ciascuno

1_' rilasciare uno da ciascuno

— NGN
fonte
3

Japt , 15 byte

Restituisce una matrice di linee

Ôå+ ®¬qV êÃûV ê

Provalo

Ôå+ ®¬qV êÃûV ê     :Implicit input of strings U=s & V=c
Ô                   :Reverse U
 å+                 :Prefixes
    ®               :Map
     ¬              :  Split
      qV            :  Join with V
         ê          :  Palindromise
          Ã         :End map
           ûV       :Centre pad each string with V, to the length of the longest
              ê     :Palindromise
— ispido
fonte
3

Carbone , 15 byte

ＵＢηＥθ✂θκ‖Ｏ↑←ＵＥ¹

Provalo online! Il collegamento è alla versione dettagliata del codice. Originariamente inviato come commento sul post sandbox ora eliminato . Spiegazione:

ＵＢη

Imposta lo sfondo sul secondo input c.

Ｅθ✂θκ

Mappa sopra il primo input sper generare tutti i suffissi e stamparli implicitamente su righe separate.

‖Ｏ↑←

Rifletti in orizzontale e in verticale.

ＵＥ¹

Aggiungi spazio extra in orizzontale.

— Neil
fonte
3

Rubino , 95 84 75 byte

->a,c{(1...2*z=a.size).map{|i|s=a[j=(z-i).abs,z]*c+c*2*j;s.reverse.chop+s}}

Provalo online!

Prende la stringa di input come una matrice di caratteri. Restituisce una matrice di stringhe.

— Kirill L.
fonte
2

PowerShell , 120 byte

param($s,$c)($s,(($l=$s.length-1)..0+1..$l|%{($x=$c*(2*$_))+($s[($_,($l..$_+($_+1)..$l))[$_-ne$l]]-join$c)+$x}))[$l-gt0]

Provalo online!

Alcuni giorni, avere intervalli di indice invece di sezioni fa davvero male. Oggi è uno di quei giorni. A causa di intervalli congiunti che creano problemi quando si tratta di singoli elementi (ad es. Restituendo 0..0 + 1..0), viene utilizzato un involucro speciale per evitarlo del tutto (al costo di molti byte).

— Veskah
fonte
2

PowerShell , 82 83 byte

+2 byte grazie Veskah: corretto il bug del caso a carattere singolo

-1 byte: la regola Input-string may also be a list of charactersutilizzata

$c,$s=$args
($s|%{(-join$s|% s*g $i)+$c*$i++})[($r=$i..0+1..$i)]|%{"$_"[$r]-join$c}

Provalo online!

Meno golf:

$c,$s=$args
$southEast = $s|%{
    (-join$s|% substring $i) + $c*$i++
}
$range=$i..0+1..$i
$southEast[$range]|%{
    "$_"[$range]-join$c
}
— Mazzy
fonte
1
Sembra che questo si rompa per il caso di un singolo personaggio. C'è solo una linea vuota nel collegamento TIO per~
— Veskah,
Infatti. Grazie!
— mazzy
2

Pip , 24 20 byte

QPRV:_JbMa@>RV,#aZDb

Usa il -l flag per ottenere un output leggibile dall'uomo. Provalo online!

Spiegazione

QPRV:_JbMa@>RV,#aZDb
                      a,b are cmdline args (implicit)
                a     1st cmdline arg (the string)
               #      Length
              ,       Range
            RV        Reverse
         a@>          Take slices of a starting at those indices
                 ZDb  Zip the list of slices together, filling out missing values in
                      the matrix with b (the character)
        M             To each row, map this function:
     _Jb               Join on b
  RV:                 Reverse (making top row the bottom and vice versa)
QP                    Quad-palindromize: reflect downward and rightward, with overlap

Ad esempio, con input di abcde .:

RV,#a
 [3 2 1 0]
a@>
 ["d" "cd" "bcd" "abcd"]
ZDb
 [['d 'c 'b 'a] ['. 'd 'c 'b] ['. '. 'd 'c] ['. '. '. 'd]]
_JbM
 ["d.c.b.a" "..d.c.b" "....d.c" "......d"]
RV:
 ["......d" "....d.c" "..d.c.b" "d.c.b.a"]
QP
 ["......d......" "....d.c.d...." "..d.c.b.c.d.." "d.c.b.a.b.c.d" "..d.c.b.c.d.." "....d.c.d...." "......d......"]
— DLosc
fonte
2

Attache , 57 byte

${q:=#x-1Bounce!Bounce@Join&y@PadLeft&y&#x=>x[q::(q::0)]}

Provalo online!L'output è un elenco di righe.

Spiegazione

?? parameters: x, y
${
    ?? q is length of x - 1
    q:=#x-1
    ?? Reflect, collapsing middle:
    Bounce!
        ?? Function:
            ?? Reflect,
            Bounce@
            ?? Joined by y,
            Join&y@
            ?? padded to the length of x with y
            PadLeft&y&#x
        ?? Mapped over
        =>
            ?? The elements of x at
            x[
                ?? decreasing range from q to
                q::(
                    ?? each element in the range from q to 0
                    q::0
                )
            ]
}
— Conor O'Brien
fonte
2

Perl 6 , 79 byte

->\c{{map {join c,g $_ X||c},g .[^*X+(^$_,)]}o*.comb}
my&g={.[$_-1...0...$_-1]}

Provalo online!

Blocco codice anonimo che accetta input al curry (come f(char)(string) ) e restituisce un elenco di righe. Penso che un approccio diverso sarebbe più breve.

Spiegazione:

my&g={.[$_-1...0...$_-1]}  # Helper function to palindromise a list
->\c{                                                }  # Code block that takes a char
     {                                       }o*.comb   # And returns a function
                                .[^*X+(^$_,)]  # Get all prefixes with end padding
                                               # e.g. "str" => [["r",Nil,Nil]
                                                                ["t","r",Nil]
                                                                ["s","t","r"]]
                              g   # Palindromise the lsit
       map {                },    # Map each element to
                     $_ X||c      # Replace all Nils with the character
                   g              # Palindromise it
            join c,               # And join by the character
— Jo King
fonte
1

JavaScript (Node.js) , 143 byte

(s,c)=>{q=Math.abs;m=(l=s.length*4-3)-1;for(i=j=0;j<l/2;(i=(++i)%l)?0:++j){p=s[q(i-m/2)/2+q(j-m/4)];process.stdout.write((i?"":"\n")+(p?
p:c))}}

Provalo online!

Un po 'più di pensiero porterebbe a calcolare in termini di un array monodimensionale e meno byte.

— Igor Sowinski
fonte
1

Kotlin , 250 byte

Nota: Kotlin tio attualmente non restituisce una nuova classe, quindi questo codice ottiene un'eccezione puntatore null. Questo si verifica anche per i codici che ho precedentemente pubblicato che funzionavano in quel momento. Presumo che alla fine verrà risolto, ma non sono riuscito a trovare un contatto di supporto per segnalare il problema. Può anche essere eseguito qui .

{s:String,c:Char->val h=s.length*2-1
val w=h*2-1
val m=Array(h){Array(w){c}}
for(i in s.indices)for(r in 0..h-1){val o=(i-Math.abs(h/2-r))*2
if(o>=0){m[r][w/2+o]=s[i].toChar()
m[r][w/2-o]=s[i].toChar()}}
m.map{it.joinToString("")}.joinToString("\n")}

Provalo online!

— JohnWells
fonte
Puoi contattare @Dennis in chat di The Ninteenth Byte . È il moderatore di TIO. Inoltre, consento di restituire un elenco di stringhe invece di stamparle effettivamente, quindi penso (non sono sicuro) che sia possibile rimuovere il .joinToString("\n")conteggio dei byte (e farlo nel piè di pagina esterno alla funzione).
— Kevin Cruijssen,
1

Interrogazione TSQL, 191 byte

In MS-SQL Server Management Studio premere Ctrl-T prima di eseguire questa query, questo cambierà l'output in testo.

Questo script sta creando l'output da sinistra a destra in una lunga "stringa", calcolando il valore da inserire in ciascuna posizione. L'output è limitato a 4096 caratteri.

golfed:

SELECT
string_agg(iif(h>k/2,@y,substring(@,h+1,1))+iif(-~n%k=0,'
',@y),'')FROM(SELECT
abs(k/2-n%k)+abs(k/2-n/k)h,*FROM(SELECT
number n,len(@)*2-1k,*FROM spt_values)c)d
WHERE n<k*k and'P'=type

Ungolfed:

USE master
DECLARE 
@y char='.',
@ varchar(20) = 'abcd'

SELECT
  string_agg(iif(h>k/2,@y,substring(@,h+1,1))+iif(-~n%k=0,'
',@y),'')
FROM
(
  SELECT
    abs(k/2-n%k)+abs(k/2-n/k)h,*
  FROM
  (
    SELECT
      number n,
      len(@)*2-1k,*
    FROM spt_values
  )c
)d
WHERE n<k*k and'P'=type

Ho dovuto apportare alcune modifiche per formattare l'output nella versione online.

Provalo online

— t-clausen.dk
fonte
1

Java (JDK) , 213 199 198 byte

a->b->{int i=0,l=a.length()-1;String s=a,r[]=new String[l-~l],p;for(;i<=l;s=s.substring(1))r[l+i]=r[l-i]=new StringBuffer(p=b.join(b,s.split(""))+b.repeat(2*i++)).reverse()+p.substring(1);return r;}

Provalo online!

-14 bytes grazie a @KevinCruijssen
-1 byte grazie a @ceilingcat

Ungolfed

a->
    b-> {
        int i = 0, l = a.length() - 1;
        String s = a, r[]=new String[a.length()*2-1],p;
        for (; i<=l; s=s.substring(1))
            r[l+i]
              = r[l-i++]
              =   new StringBuffer(
                                   p =   String.join(b,s.split(""))
                                       + b.repeat(2*i)
                                  ).reverse()
                + p.substring(1);
        return r;
    }
— Sara J
fonte
1
Bella risposta, puoi comunque giocare a golf di 14 byte sotto 200 . :)
— Kevin Cruijssen il
@KevinCruijssen Ben individuato, grazie!
— Sara J,
@ceilingcat Bel pensiero, grazie!
— Sara J,
1

Wolfram Language (Mathematica) , 68 byte

Table[#[[1+Abs@y+Abs@x/2]]/._@__:>#2,{y,l=1-Tr[1^#],-l},{x,2l,-2l}]&

Provalo online!

Prende un elenco di caratteri (insieme al carattere di riempimento) come input e genera una matrice di caratteri.

Table[                              ,{y,l=1-Tr[1^#],-l},{x,2l,-2l}]&    (* make a (2*len-1 x 4*len-3) table centered at (0,0) *)
      #[[               ]]                                              (*  where the value at each point is the string indexed at *)
         1+Abs@y+Abs@x/2                                                (*   (1 + |y-coordinate| + |x-coordinate|/2) *)
                          /._@__:>#2                                    (*  if that indexing fails, use the filler character instead *)

Per prendere l'indice dell'elenco di caratteri, utilizziamo list[[index]], che viene espanso internamente Part[list, index]. Se l'indice è valido, quell'espressione valuta il valore di quell'indice. In caso contrario, se l'indice non è un numero intero o è fuori intervallo, l'espressione rimane non valutata.
Il modello più semplice (più breve) che corrisponde Part[...]ma non un singolo carattere è _@__, che corrisponde a qualsiasi espressione con uno o più argomenti.

— attinat
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.