Disposez le tapis

40

Inspiré par cette question SO .

Défi:

Contribution:

  • Une chaînes
  • Un personnagec

Sortie:

Créez un dessin ASCII carré en losange de la chaîne dans les quatre directions, avec le premier caractère de la chaîne au centre et vers l'extérieur. Qui est à l'intérieur d'un tapis carré ASCII-art, avec le caractère comme charge. Cela peut paraître assez vague, voici donc un exemple:

Entrée: s = string, c = .
sortie:

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

Règles du challenge:

  • La chaîne d'entrée peut également être une liste de caractères
  • La sortie peut également être une liste de lignes ou une matrice de caractères
  • La chaîne d'entrée et le caractère sont garantis non vides
  • La chaîne est garantie de ne pas contenir le caractère
  • La chaîne et le caractère ne seront que des caractères ASCII imprimables (plage unicode [32,126], espace '' jusqu'au tilde et incluant '~')

Règles générales:

  • C'est du code-golf , donc la réponse la plus courte en octets est gagnante.
    Ne laissez pas les langues de code-golf vous décourager de poster des réponses avec des langues autres que le code de golf. Essayez de trouver une réponse aussi courte que possible à n'importe quel langage de programmation.
  • Les règles standard s'appliquent à votre réponse avec les règles d'E / S par défaut . Vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type de retour, de type renvoyé. Ton appel.
  • Les failles par défaut sont interdites.
  • Si possible, veuillez ajouter un lien avec un test pour votre code (c.-à-d. TIO ).
  • En outre, l'ajout d'une explication de votre réponse est fortement recommandé.

Cas de test:

Entrée: s = 11111, c= = 0
Rendement:

00000000100000000
00000010101000000
00001010101010000
00101010101010100
10101010101010101
00101010101010100
00001010101010000
00000010101000000
00000000100000000

Entrée: s = 12345ABCDEF, c = #
sortie:

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

Contribution: s = @+-|-o-|-O, = sortie:c:

::::::::::::::::::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::::::::::::::::::

Entrée: s = , = sortie:cABcc

ccBcc
BcAcB
ccBcc

Entrée: = , = sortie:s~cX

~

Contribution: sc = /\^/\, = sortie:cX

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
source
La chaîne peut-elle contenir des espaces?
— Emigna
1
@ Emigna Oui, tous les caractères ASCII imprimables (plage unicode [32, 126]) sont des caractères d'entrée valides.
— Kevin Cruijssen
1
Cela devient merveilleux à déboguer si vous utilisez des caractères qui ressemblent visuellement à un seul caractère, par exemple ()()().
— Filip Haglund
Que devrait-il se passer si $ s $ est vide?
— Solomon Ucko
@SolomonUcko De la section des règles: " La chaîne d'entrée et le caractère sont assurés d'être non vides " :)
— Kevin Cruijssen

Réponses:

6

R , 118 95 92 octets

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)

Essayez-le en ligne!

Grâce à:

  • Giuseppe pour avoir corrigé une erreur et un golf
  • Aaron Hayman pour 22 octets de golf
— Kirill L.
source
Je suppose que je dois abandonner mon aversion pour les forboucles en R, du moins pour le golf.
— Aaron Hayman
@ Giuseppe, merci, je ne devrais pas être si paresseux à propos de l'inclusion de cas de test supplémentaires!
— Kirill L.
1
Ceci pour 98 semble plus proche de votre solution que la mienne Essayez-le en ligne!
— Aaron Hayman
1
peut décoller deux autres avec un peu de réarrangement: Essayez-le en ligne!
— Aaron Hayman
1
@AaronHayman ou bien ce 92 octets combinant la pminlogique avec le réarrangement :-)
— Giuseppe
5

R , une version laide de 118 octets

En laissant l'entrée être un vecteur de caractères uniques, et en affichant une matrice au lieu d'imprimer un bel art 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)

Essayez-le en ligne!

R , 161 157 octets

sauvegardé 4 octets en utilisant ifelse au lieu de modifier conditionnellement 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='')

Essayez-le en ligne!

non golfé et commenté

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, semble être la réponse la plus longue à ce jour!

— Aaron Hayman
source
Oh mon Dieu, j'aurais dû mieux regarder la question
— Aaron Hayman
1
@KevinCruijssen je l'ai corrigé maintenant
— Aaron Hayman
1
pour +15 octets, vous pouvez faire votre réponse laide ascii-art: essayez-le en ligne!
— Giuseppe
4

05AB1E , 15 à 11 octets

.sûsζøsýí€û

Essayez-le en ligne! ou en tant que suite de tests

Explication

.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
source
1
@ KevinCruijssen: Ouais. Heureusement, il n'a pas coûté d'octets pour le réparer. Je pense toujours qu'il devrait y avoir une meilleure façon de faire cela, alors je vais continuer à chercher.
— Emigna
"Le résultat peut également être une liste de lignes ou une matrice de caractères ", vous pouvez donc déplacer le curseur »vers le pied de page. :)
— Kevin Cruijssen
@ KevinCruijssen Ah oui. J'ai jeté un coup d'œil sur cette partie. Merci :)
— Emigna
4

J , 35 34 33 octets

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

Essayez-le en ligne!


-&#cs
i:
1-|+/|
{: (<*-)-&#

 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

Les indices négatifs commencent à -1 comme en python. Il ne reste plus qu'à insérer les colonnes de zéros.

1j1( #"1
  }:@
,{~cs

Merci beaucoup à Galen Ivanov pour l'algorithme.

— FrownyFrog
source
Souhaitez-vous ajouter une explication? Je ne connais pas bien J.
— Kevin Cruijssen
4

K (ngn / k) , 38 octets

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

Essayez-le en ligne!

{ }fonction avec arguments x(la chaîne s ) et y(le caractère c )

|x sens inverse x

y,'ajouter yà chacun

+ transposer

,/ concat

1_ déposer le premier personnage

à ce stade, nous avons une chaîne d' xoccurrences de length ( ) ysuivies des caractères dex

#x longueur de x

(#x)' fenêtre coulissante de ce nombre de caractères consécutifs

2{ }/ faire deux fois

+x,1_|xrejoindre xavec l'inverse xsans son premier élément, et transposer

y,''ajouter yà chaque chacun

,/' concat chaque

1_' déposer un de chaque

— ngn
source
3

Japt , 15 octets

Retourne un tableau de lignes

Ôå+ ®¬qV êÃûV ê

L'essayer

Ôå+ ®¬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
— Hirsute
source
3

Charbon de bois , 15 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Initialement soumis en tant que commentaire sur le message Sandbox maintenant supprimé . Explication:

ＵＢη

Définissez l'arrière-plan sur la deuxième entrée c.

Ｅθ✂θκ

Mappez sur la première entrée spour générer tous les suffixes et les imprimer implicitement sur des lignes séparées.

‖Ｏ↑←

Reflète horizontalement et verticalement.

ＵＥ¹

Ajouter un espace supplémentaire horizontalement.

— Neil
source
3

Ruby , 95 84 75 octets

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

Essayez-le en ligne!

Prend la chaîne d'entrée comme un tableau de caractères. Retourne un tableau de chaînes.

— Kirill L.
source
2

Japt , 16 octets

Note: je vais jouer au golf :)

Ôå+ ®¬qVÃùV mê ê

Essayez-le en ligne!

— Luis Felipe De Jesus Munoz
source
C'est assez similaire à l'autre réponse Japt, mais dans un ordre différent, n'est-ce pas? Je ne connais pas Japt, mais je vois des caractères similaires dans les deux réponses. ;)
— Kevin Cruijssen
@KevinCruijssen Ouais, les deux sont presque identiques, pour le moment
— Luis Felipe De jesus Munoz
@KevinCruijssen, Luis l'a développé indépendamment de ma solution.
— Shaggy
2

PowerShell , 120 octets

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]

Essayez-le en ligne!

Certains jours, avoir des plages d'index au lieu de tranches fait vraiment mal. Aujourd'hui est l'un de ces jours. En raison de la confusion des plages lorsque des éléments uniques sont manipulés (par exemple, renvoyer 0..0 + 1..0), une casse spéciale est utilisée pour l'éviter complètement (au prix de plusieurs octets).

— Veska
source
2

PowerShell , 82 83 octets

+2 octets merci Veskah: correction du problème de casse à un caractère

-1 octet: la règle Input-string may also be a list of charactersutilisée

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

Essayez-le en ligne!

Moins joué au golf:

$c,$s=$args
$southEast = $s|%{
    (-join$s|% substring $i) + $c*$i++
}
$range=$i..0+1..$i
$southEast[$range]|%{
    "$_"[$range]-join$c
}
— mazzy
source
1
On dirait que ça casse pour le cas à caractère unique. Il y a juste une ligne vide dans le lien TIO pour~
— Véska
Effectivement. Merci!
— mazzy
2

Pip , 24 20 octets

QPRV:_JbMa@>RV,#aZDb

Utilisez le -ldrapeau pour obtenir une sortie lisible par l'homme. Essayez-le en ligne!

Explication

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

Par exemple, avec les entrées de abcdet .:

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
source
2

Attaché , 57 octets

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

Essayez-le en ligne! La sortie est une liste de lignes.

Explication

?? 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
source
2

Perl 6 , 79 octets

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

Essayez-le en ligne!

Codeblock anonyme qui prend une entrée au curry (comme f(char)(string)) et renvoie une liste de lignes. Je pense qu'une approche différente serait plus courte.

Explication:

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
source
1

JavaScript (Node.js) , 143 octets

(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))}}

Essayez-le en ligne!

Un peu plus de réflexion conduirait à calculer en termes de tableau unidimensionnel et moins d'octets.

— Igor Sowinski
source
1

Kotlin , 250 octets

Remarque: Kotlin tio ne parvient pas à renvoyer une nouvelle classe. Ce code obtient donc une exception de pointeur null. Cela se produit également pour les codes que j'ai précédemment publiés et qui fonctionnaient à ce moment-là. Je suppose que cela va éventuellement être résolu, mais je n'ai pas trouvé de contact technique pour signaler le problème. Il peut également être exécuté ici .

{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")}

Essayez-le en ligne!

— JohnWells
source
Vous pouvez contacter @Dennis à The Ninteenth Byte chat . Il est le modérateur de TIO. De plus, je permets de renvoyer une liste de chaînes au lieu d’imprimer, je pense donc (non sûr) que vous pouvez supprimer le nombre .joinToString("\n")d’octets (et le faire dans le pied de page en dehors de la fonction).
— Kevin Cruijssen
1

Requête TSQL, 191 octets

Dans MS-SQL Server Management Studio, appuyez sur Ctrl-T avant d'exécuter cette requête. La sortie sera transformée en texte.

Ce script construit la sortie de gauche à droite dans une longue "chaîne", en calculant la valeur à mettre à chaque position. La sortie est limitée à 4096 caractères.

Golfé:

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

J'ai dû faire quelques changements pour formater la sortie dans la version en ligne.

Essayez-le en ligne

— t-clausen.dk
source
1

Java (JDK) , 213 199 198 octets

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;}

Essayez-le en ligne!

-14 bytes grâce à @KevinCruijssen
-1 byte grâce à @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
source
1
Bonne réponse, vous pouvez jouer au golf par 14 octets en dessous de 200 cependant . :)
— Kevin Cruijssen le
@KevinCruijssen Bien repéré, merci!
— Sara J
@ceilingcat Bonne réflexion, merci!
— Sara J
1

Wolfram Language (Mathematica) , 68 octets

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

Essayez-le en ligne!

Prend une liste de caractères (avec le caractère de remplissage) en entrée et génère une matrice de caractères.

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 *)

Pour prendre l’index de la liste de caractères, nous utilisons list[[index]], qui est développé en interne Part[list, index]. Si l'index est valide, cette expression est évaluée à la valeur de cet index. Si ce n'est pas le cas - si l'index n'est pas un entier ou s'il est hors limites - l'expression n'est pas évaluée.
Le modèle le plus simple (le plus court) qui correspond, Part[...]mais pas un seul caractère _@__, correspond à toute expression avec un ou plusieurs arguments.

— attinat
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.