Legen Sie den Teppich aus

40

Inspiriert von dieser SO-Frage .

Herausforderung:

Eingang:

  • Eine Zeichenfolges
  • Ein Charakterc

Ausgabe:

Erstellen Sie eine rautenförmige ASCII-Grafik der Zeichenfolge in alle vier Richtungen, wobei das erste Zeichen der Zeichenfolge in der Mitte und nach außen zeigt. Welches ist in einem quadratischen ASCII-Art-Teppich, mit dem Charakter als Füllstoff. Das mag ziemlich vage klingen, also hier ein Beispiel:

Eingabe: = , = Ausgabe: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..........

Herausforderungsregeln:

  • Die Eingabezeichenfolge kann auch eine Liste von Zeichen sein
  • Die Ausgabe kann auch eine Liste von Zeichenketten oder eine Matrix von Zeichen sein
  • Eingabezeichenfolge und Zeichen sind garantiert nicht leer
  • Die Zeichenfolge enthält garantiert kein Zeichen
  • Sowohl der String als auch das Zeichen können nur als ASCII-Zeichen gedruckt werden (Unicode-Bereich [32,126], Leerzeichen '' bis einschließlich Tilde '~').

Allgemeine Regeln:

  • Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
    Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
  • Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
  • Standardlücken sind verboten.
  • Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
  • Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

Eingabe: = , = Ausgabe:s11111c=0

00000000100000000
00000010101000000
00001010101010000
00101010101010100
10101010101010101
00101010101010100
00001010101010000
00000010101000000
00000000100000000

Eingabe: = , = Ausgabe: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####################

Eingabe: = , = Ausgabe:sc@+-|-o-|-Oc:

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

Eingabe: = , = Ausgabe:scABcc

ccBcc
BcAcB
ccBcc

Eingabe: s = ~, c = X
Ausgabe:

~

Eingabe: s = /\^/\, c = X
Ausgabe:

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
quelle
Kann der String Leerzeichen enthalten?
— Emigna
1
@Emigna Ja, alle druckbaren ASCII-Zeichen (Unicode-Bereich [32,126]) sind gültige Eingabezeichen.
— Kevin Cruijssen
1
Dies lässt sich wunderbar debuggen, wenn Sie Zeichen verwenden, die optisch wie ein einzelnes Zeichen aussehen, z ()()().
— Filip Haglund
Was soll passieren, wenn $ s $ leer ist?
— Solomon Ucko
@SolomonUcko Aus dem Abschnitt mit den Regeln: "Eingabezeichenfolge und Zeichen sind garantiert nicht leer " :)
— Kevin Cruijssen

Antworten:

6

R , 118 95 92 Bytes

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)

Probieren Sie es online!

Dank an:

  • Giuseppe für die Behebung eines Fehlers und ein Golf
  • Aaron Hayman für 22 Bytes Golf
— Kirill L.
quelle
Ich denke, ich muss meine Abneigung gegen forLoops in R ablegen, zumindest zum Golfen.
— Aaron Hayman
@ Giuseppe, danke, ich sollte nicht so faul sein, zusätzliche Testfälle aufzunehmen!
— Kirill L.
1
Dies für 98 scheint Ihrer Lösung näher zu sein als meine. Probieren Sie es online aus!
— Aaron Hayman
1
kann mit ein bisschen Umlagerung noch zwei ausziehen: Online ausprobieren!
— Aaron Hayman
1
@AaronHayman oder auch diese 92 Byte, die die pminLogik mit der Umlagerung kombiniert :-)
— Giuseppe
5

R , eine hässliche 118-Byte-Version

Indem die Eingabe ein Vektor aus einzelnen Zeichen ist und eine Matrix ausgegeben wird, anstatt schöne ASCII-Grafiken zu drucken.

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)

Probieren Sie es online!

R , 161 157 Bytes

4 Bytes gespart durch Verwendung von ifelse anstelle von bedingten Änderungen 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='')

Probieren Sie es online!

ungolfed und kommentiert

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, scheint die längste Antwort zu sein!

— Aaron Hayman
quelle
Oh je, hätte die Frage besser untersuchen sollen
— Aaron Hayman
1
@ KevinCruijssen Ich habe es jetzt behoben
— Aaron Hayman
1
Für +15 Bytes können Sie Ihre hässliche Antwort ASCII-Kunst machen: Probieren Sie es online!
— Giuseppe
4

05AB1E , 15 11 Bytes

.sûsζøsýí€û

Probieren Sie es online! oder als Testsuite

Erläuterung

.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
quelle
1
@ KevinCruijssen: Ja. Zum Glück hat es keine Bytes gekostet, es zu reparieren. Ich habe immer noch das Gefühl, dass es einen besseren Weg geben sollte, das zu tun, also werde ich weiter suchen.
— Emigna
Msgstr "Die Ausgabe kann auch eine Liste von Zeichenketten oder eine Matrix von Zeichen sein ", so dass Sie »das Symbol in die Fußzeile verschieben können. :)
— Kevin Cruijssen
@ KevinCruijssen Ah richtig. Ich warf einen Blick auf diesen Teil. Danke :)
— Emigna
4

J , 35 34 33 Bytes

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

Probieren Sie es online!


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

Negative Indizes beginnen wie in Python bei -1. Sie müssen nur noch die Spalten mit den Nullen einfügen.

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

Vielen Dank an Galen Ivanov für den Algorithmus.

— FrownyFrog
quelle
Würde es Ihnen etwas ausmachen, eine Erklärung hinzuzufügen? Ich bin nicht so vertraut mit J.
— Kevin Cruijssen
4

K (ngn / k) , 38 Bytes

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

Probieren Sie es online!

{ }Funktion mit Argumenten x(die Zeichenfolge s ) und y(das Zeichen c )

|x umkehren x

y,'yjedem voranstellen

+ transponieren

,/ concat

1_ Lass das erste Zeichen fallen

An dieser Stelle haben wir eine Folge von length ( x) -Instanzen ygefolgt von den Zeichen vonx

#x Länge von x

(#x)' Schiebefenster von so vielen aufeinanderfolgenden Zeichen

2{ }/ zweimal machen

+x,1_|xverbinden xmit dem umgekehrt , xohne das erste Element, und transponieren

y,''yjedem voranstellen

,/' concat jeder

1_' lassen Sie eins von jedem fallen

— ngn
quelle
3

Japt , 15 Bytes

Gibt ein Array von Zeilen zurück

Ôå+ ®¬qV êÃûV ê

Versuch es

Ôå+ ®¬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
— Zottelig
quelle
3

Kohle , 15 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Ursprünglich als Kommentar zum nun gelöschten Sandbox-Beitrag eingereicht . Erläuterung:

ＵＢη

Stellen Sie den Hintergrund auf den zweiten Eingang ein c.

Ｅθ✂θκ

Ordnen Sie die erste Eingabe szu, um alle Suffixe zu generieren und implizit in separaten Zeilen zu drucken.

‖Ｏ↑←

Horizontal und vertikal reflektieren.

ＵＥ¹

Fügen Sie horizontal zusätzlichen Platz hinzu.

— Neil
quelle
3

Ruby , 95 84 75 Bytes

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

Probieren Sie es online!

Nimmt die Eingabezeichenfolge als ein Array von Zeichen. Gibt ein Array von Zeichenfolgen zurück.

— Kirill L.
quelle
2

Japt , 16 Bytes

Hinweis: Ich werde es Golf spielen :)

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

Probieren Sie es online!

— Luis Felipe De Jesus Munoz
quelle
Es ist der anderen Japt-Antwort ziemlich ähnlich, aber in einer anderen Reihenfolge, nicht wahr? Ich kenne Japt nicht, aber ich sehe in beiden Antworten ähnliche Charaktere. ;)
— Kevin Cruijssen
@ KevinCruijssen Ja, beide sind im Moment fast gleich
— Luis Felipe De Jesus Munoz
@ KevinCruijssen, Luis hat dies unabhängig von meiner Lösung entwickelt.
— Shaggy
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]

Probieren Sie es online!

An manchen Tagen schmerzt es wirklich, Indexbereiche anstelle von Slices zu haben. Heute ist einer dieser Tage. Aufgrund der Verwechslung von verbundenen Bereichen beim Umgang mit einzelnen Elementen (z. B. Rückgabe von 0..0 + 1..0) wird eine spezielle Groß- / Kleinschreibung verwendet, um dies insgesamt zu vermeiden (auf Kosten vieler Bytes).

— Veskah
quelle
2

PowerShell , 82 bis 83 Byte

+2 Bytes dank Veskah: Der Fehler in der Groß- und Kleinschreibung wurde behoben

-1 Byte: Die Regel Input-string may also be a list of charactersverwendet

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

Probieren Sie es online!

Weniger golfen:

$c,$s=$args
$southEast = $s|%{
    (-join$s|% substring $i) + $c*$i++
}
$range=$i..0+1..$i
$southEast[$range]|%{
    "$_"[$range]-join$c
}
— mazzy
quelle
1
Sieht so aus, als würde dies für die Groß- und Kleinschreibung eines einzelnen Zeichens unterbrochen. Es gibt nur eine leere Zeile im TIO-Link für~
— Veskah
Tatsächlich. Vielen Dank!
— mazzy
2

Pip , 24 bis 20 Bytes

QPRV:_JbMa@>RV,#aZDb

Verwenden Sie das -lFlag, um eine lesbare Ausgabe zu erhalten. Probieren Sie es online!

Erläuterung

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

Zum Beispiel mit Eingaben von abcdund .:

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

Attache , 57 Bytes

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

Probieren Sie es online! Ausgabe ist eine Liste von Zeilen.

Erläuterung

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

Perl 6 , 79 Bytes

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

Probieren Sie es online!

Anonymer Codeblock, der Eingaben wie "curried" annimmt f(char)(string)und eine Liste von Zeilen zurückgibt. Ich denke, ein anderer Ansatz wäre kürzer.

Erläuterung:

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
— Scherzen
quelle
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))}}

Probieren Sie es online!

Ein bisschen mehr Nachdenken würde zu Berechnungen in Form eines eindimensionalen Arrays und weniger Bytes führen.

— Igor Sowinski
quelle
1

Kotlin , 250 Bytes

Hinweis: Kotlin tio kann derzeit keine neue Klasse zurückgeben, sodass dieser Code eine Nullzeigerausnahme erhält. Dies gilt auch für Codes, die ich zuvor veröffentlicht habe und die zu diesem Zeitpunkt funktionierten. Ich gehe davon aus, dass es irgendwann behoben wird, konnte aber keinen Support-Kontakt finden, an den das Problem gemeldet werden kann. Es kann auch hier ausgeführt werden .

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

Probieren Sie es online!

— JohnWells
quelle
Sie können @Dennis im The Ninteenth Byte Chat kontaktieren . Er ist der Moderator für TIO. Außerdem erlaube ich die Rückgabe einer Liste von Zeichenfolgen, anstatt sie tatsächlich zu drucken. Ich bin mir also nicht sicher, ob Sie die Zeichenfolge .joinToString("\n")aus der Byteanzahl entfernen können (und zwar in der Fußzeile außerhalb der Funktion).
— Kevin Cruijssen
1

TSQL-Abfrage, 191 Byte

Drücken Sie in MS-SQL Server Management Studio Strg-T, bevor Sie diese Abfrage ausführen. Dadurch wird die Ausgabe in Text geändert.

Dieses Skript baut die Ausgabe von links nach rechts in einer langen "Zeichenfolge" auf und berechnet den Wert, der an jeder Position eingefügt werden soll. Die Ausgabe ist auf 4096 Zeichen begrenzt.

Golf gespielt:

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

Ich musste einige Änderungen vornehmen, um die Ausgabe in der Online-Version zu formatieren.

Probieren Sie es online aus

— t-clausen.dk
quelle
1

Java (JDK) , 213 199 198 Bytes

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

Probieren Sie es online!

-14 bytes danke an @KevinCruijssen
-1 byte danke an @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
quelle
1
Schöne Antwort, Sie können es jedoch um 14 Bytes unter 200 golfen . :)
— Kevin Cruijssen
@ KevinCruijssen Gut gesehen, danke!
— Sara J
@ceilingcat Nettes Denken, danke!
— Sara J
1

Wolfram-Sprache (Mathematica) , 68 Byte

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

Probieren Sie es online!

Nimmt eine Liste von Zeichen (zusammen mit dem Füllzeichen) als Eingabe und gibt eine Zeichenmatrix aus.

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

Um den Index der Liste der Zeichen zu nehmen, verwenden wir list[[index]], der intern erweitert wird, um Part[list, index]. Wenn der Index gültig ist, wird dieser Ausdruck zu dem Wert an diesem Index ausgewertet. Wenn nicht - wenn der Index keine Ganzzahl ist oder außerhalb des Bereichs liegt - bleibt der Ausdruck unbewertet.
Das einfachste (kürzeste) Muster , das mit einem oder mehreren Argumenten übereinstimmt, Part[...]jedoch nicht mit einem einzelnen Zeichen, ist _@__, dass ein Ausdruck mit einem oder mehreren Argumenten übereinstimmt.

— attinat
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.