Aiuto! Il mio dispositivo non funziona e ogni volta che provo a ripetere una stringa, ottengo risultati confusi. Invece di ripetere la stessa stringa N volte, riempie un quadrato NxN con ciascuno dei suoi caratteri e impila i quadrati.

Ad esempio, data la stringa "Test"e il numero 2, invece di "TestTest", ottengo:

TT
TT
ee
ee
ss
ss
tt
tt

Dopo averlo visto per un po ', ho iniziato a piacermi. Il tuo compito oggi è riprodurre questo strano comportamento. Data una stringa non vuota che consiste solo di ASCII stampabile e un numero intero positivo , restituisce la stringa restituita dal dispositivo non funzionante.

• Si applicano tutte le regole standard.

• L'input e l'output possono essere gestiti con qualsiasi mezzo ragionevole.

• Questo è code-golf , quindi vince il codice più breve in byte in ogni lingua.

Casi test

Ingresso 
Produzione

----------

"Test", 2

TT
TT
EE
EE
ss
ss
TT
TT

----------

"UuU", 3

UUU
UUU
UUU
uuu
uuu
uuu
UUU
UUU
UUU

----------

"A", 5

AAAAA
AAAAA
AAAAA
AAAAA
AAAAA

----------

Puoi trovare un caso di prova più grande qui . Buona fortuna e buon divertimento!

Gelatina , 4 byte

Ispirato dall'abuso di gelatina di Mr. Xcoder

x⁹×Y

Un programma completo che prende la stringa e il numero come argomenti della riga di comando e stampa il risultato (poiché come collegamento diadico restituisce un elenco di stringhe e caratteri di nuova riga, il che potrebbe non essere accettabile).

Provalo online!

Come?

L'ingenuo (non abusivo) cinque byter è:

x⁹x€Y - Main link: list of characters, s; number, n  e.g. "xyz", 2
 ⁹    - chain's right argument, n                         2
x     - times (repeat each element)                       ['x','x','y','y','z','z']
  x€  - times for €ach                                   [['x','x'],['x','x'],['y','y'],['y','y'],['z','z'],['z','z']]
    Y - join with newlines                                ['x','x','\n','x','x','\n','y','y','\n','y','y','\n','z','z','\n','z','z']
      - as a full program: implicit print
      -   note: this could be submitted as a dyadic link (AKA unnamed function)

L'abuso usato da Mr. Xcoder (Python operator.mulpuò agire su un stre un intper ripetere il str- qui singoli personaggi - e l'atomo che lo usa ×, vettorializza il suo argomento di sinistra) può essere usato anche qui per sostituire x€con ×- dando l'intero programma :

x⁹×Y - Main link: list of characters, s; number, n  e.g. "xyz", 2
 ⁹   - chain's right argument, n                         2
x    - times (repeat each element)                       ['x','x','y','y','z','z']
  ×  - multiply (vectorises)                             ["xx","xx","yy","yy","zz","zz"]
     -     (note, these "..." are actually strings, something not usually seen in Jelly) 
    Y - join with newlines                                ["xx",'\n',"xx",'\n',"yy",'\n',"yy",'\n',"zz",'\n',"zz"]
      - implicit print

Gelatina , 5 byte

Questo è esattamente ciò che ci viene chiesto di fare ... Abusare di comportamenti indefiniti! *

×+⁷×⁴

Provalo online!

^{* Per comportamento indefinito sto parlando dell'uso ×per ripetere le stringhe. A volte è un comportamento più breve del solito, quindi perché no?}

Haskell , 26 byte

La funzione (!)restituisce un elenco di righe.

n!s=map(<$[1..n])s<*[1..n]

Provalo online!

Bash + GNU Sed, 58

Usando una tecnica molto simile a questa risposta per illustrare quanto è vicina a questa duplicazione questa domanda:

printf -vr %$1s
sed "s/./${r// /&}\n/g;s/\S*./${r// /&}/g"

Provalo online .

Buccia , 5 4 byte

-1 byte grazie a @Zgarb

SṀRṘ

Provalo online!

PowerShell , 31 byte

param($a,$b)$a|%{,("$_"*$b)*$b}

Provalo online!

Spiegazione:

param($a,$b)                    # Takes input $a (char-array) and $b (integer)
            $a|%{             } # Loop through every character in $a
                   "$_"*$b      # Construct a string of $b length of that character
                 ,(       )*$b  # Repeat that $b times
                                # Implicit Write-Output inserts a newline between elements

05AB1E , 7 5 byte

-2 byte grazie a scottinet

εײF=

Provalo online!

ε     # For each character:
 ×    #   Repeat this character N times
  ²F  #   For 0 .. N:
    = #     Print without popping 

Python 3 , 42 byte

lambda x,y:"".join(y*(r*y+"\n")for r in x)

Provalo online!

MATL , 5 byte

t&Y"!

Provalo online!

Spiegazione

t     % Implicitly input a number, n. Duplicate
&Y"   % Implicitly input a string. Three-input repelem function. Repeats
      % each entry in the first input (s) the specified numbers of times 
      % vertically (n) and horizontally (n). Gives a char matrix
!     % Transpose. Implicit display

C ++, 125 123 byte

-2 byte grazie a aschepler

#include<string>
using s=std::string;s u(s a,int b){s r;for(auto&c:a)for(int i=0;i<b*b;){if(!(i++%b))r+=10;r+=c;}return r;}

Assicurarsi che il sovraccarico +=dell'operatore chiamato abbia un chartipo di dati in questa istruzioneif(!(i++%b))r+=10

Japt , 7 byte

Emette un array di stringhe.

VÆmpVÃy

Provalo ( -Rflag solo a scopo di visualizzazione)

Spiegazione

Immissione implicita di stringa Ue numero intero V.

VÆ    Ã

Generare un array di numeri interi da 0a V-1e passare ogni attraverso una funzione.

mpV

Mappa ( m) sopra Ue ripeti ( r) ogni personaggio Vvolte.

y

Trasposizione e output implicito dell'output risultante.

R , 59 byte

function(S,n)write(rep(strsplit(S,"")[[1]],e=n*n),"",n,,"")

Scrive su stdout.

Divide la stringa in caratteri, si ripete ogni n^2volta, quindi stampa con larghezza ne senza separatore.

Provalo online!

J, ₁₅ 14 byte

[:,/]$"1 0~[,[

Sottoottimale di sicuro. Restituisce un array 2D di caratteri. Prende ncome argomento sinistro e la stringa come diritto.

Su cellulare, quindi mancano i soliti servizi.

Spiegazione

(Per la vecchia risposta)

[:,/(2#[)$"1 0]

$"1 0 rimodella ogni personaggio in

(2#[)una matrice n* n.

,/ unire le matrici insieme per produrre l'output.

Perl 5 , 26 + 1 (-p) = 27 byte

$"=<>;s|.|($&x$".$/)x$"|ge

Provalo online!

Pyth, 9 byte

VEp*+*NQb

Provalo qui!

Pyth, ₁₁ 10 byte

sm*Q+*QdbE

Provalo qui!

Oppure, 10 byte:

jsm*Q]*QdE

Oppure, 11 byte:

js*RQm]*dQE
jsm*vzm*dvz
sm*vz+*dvzb

Carbone , 9 byte

ＦＳ«ＧTＩηι↓

Provalo online!

Spiegazione

ＦＳ         For each character (i) in the next input as a string
   «
    Ｇ    ι  Polygon using i as fill
      T      Right, down, then left
       Ｉη   The second input (h) casted (to a number)
           ↓ Move down

Brainfuck, 103 byte

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

Provalo online (assicurati di attivare la memoria dinamica o non funzionerà)

Nota: l'ingresso è leggermente diverso. Questo codice contiene una stringa in cui l'ultimo carattere è una cifra per il numero di ripetizioni. Quindi l'input potrebbe apparire come Test5.

Questo codice richiede un nastro illimitato e si basa sul comportamento di wrapping dei byte.

Ungolfed:

,[>,]< Take Input
>-[>+<-----]>--- ASCII 0, to use in next step
[-<<->>]<< Convert ASCII number to raw number by subtracting ASCII 0
[->+<]> Move the number over one to separate it from the phrase
[
  [->+>+<<]>>[-<<+>>]< Copy the number
  [
    <<<[<]> Back to Letter
    . Print Letter
    [>]>>- Back to Counter
  ]
  ++++++++++.[-]< Print the newline
  <<[<]>[-]> Clear Letter
  [>]> Back to Counter
]

SOGLOnline commit 2940dbe , 4 byte

∙ι*I

Questo è stato fatto per un commit specifico, vale a dire quello prima che io cambiassi ∙, quando usato su una matrice di stringhe, ripetendo ogni lettera x volte per ripetere ogni elemento x volte. Ecco l'interprete online senza quella versione, che, come si può vedere, non funziona.

Per provare il commit, scarica questo , apri il index.htmlfile, nel programma incolla ∙ι*Ie nell'input scrivi qualcosa di simile

Test
2

Spiegazione:

∙ι*I
∙     get an array with 2nd input amount of items of the 1st input
 ι    pop one implicit input to cycle back to the number
  *   multiply horizontally each separate character
   I  rotate clockwise

Java 8, 152 128 118 100 byte

s->n->{for(char c:s)for(int j=0;j++<n;System.out.println("".valueOf(new char[n]).replace('\0',c)));}

Provalo online!

APL (Dyalog) , 8 byte

Prende la ripetizione come argomento sinistro e il testo come argomento giusto.

{⍺⌿⍺/⍪⍵}

Provalo online!

{… } Un lambda senza nome dove ⍺rappresenta l'argomento sinistro e⍵ l'argomento giusto

 ⍪⍵ trasforma il testo in una tabella a una colonna

 ⍺/ replicare ⍺ tempi in orizzontale

 ⍺⌿ replicare i ⍺tempi in verticale

Japt , 7 byte

mpV² òV

Restituisce una matrice di stringhe.

Provalo online! con il-R bandiera per unire l'array con le nuove righe.

Spiegazione

mpV² òV     Implicit input of U=string, V=number
m           Map each char in the input string to...
 pV²        Itself repeated V² times
     òV     Cut the resulting string into partitions of length V

D, 86 byte

S u(S,I)(S a,I b){S r;foreach(c;a)for(I i;i<b*b;){if(!(i++%b))r~='\n';r~=c;}return r;}

Provalo online!

Prende la stringa come argomento sinistro e il numero intero come argomento destro. Questa è una porta della risposta C ++ di HatsuPointerKun in D.

C (gcc) , 83 79 byte

i,j;f(p,n)char*p,n;{for(;*p;p++)for(i=n;i--;puts(""))for(j=n;j--;putchar(*p));}

Provalo online!

CJam, 11 byte

{__*@e*/N*}

Funzione che accetta la stringa seguita da int.

Provalo online

Kotlin 1.1 - 99 byte

fun s(s:String,c:Int)=s.flatMap{p->List(c,{p})}.joinToString("\n"){p->List(c,{p}).joinToString("")}

Restituisce l'intero output come una stringa.

Impossibile utilizzare TryItOnline in quanto 1.1 non è supportato

Test

fun s(s:String,c:Int)=s.flatMap{p->List(c,{p})}.joinToString("\n"){p->List(c,{p}).joinToString("")}

fun main(args: Array<String>) {
    println(s("Hello World", 5))
}

Sarebbe 84 se un elenco di stringhe fosse accettabile come output:

fun s(s:String,c:Int)=s.flatMap{p->List(c,{p})}.map{p->List(c,{p}).joinToString("")}

PHP, 97 byte

for($i=0;$i<strlen($s=$argv[1]);$i++)for($j=0;$j<$r=$argv[2];$j++)echo str_repeat($s[$i],$r)."
";

Mathematica, 49 byte

(z=#2;Grid[Column/@Table[#,z,z]&/@Characters@#])&

ingresso

[ "Test", 4]

Pyth , 12 byte

Di mentalità limitata, ma non ci sono ancora arrivato.

VQp*+*Nszbsz

Spiegazione:

VQ          For every letter in the first input...
  p         Print without newline...
   *+*Nszsz (The index * int(second input) + newline) * int(the second input)

Test Suite

Clojure , 82 75 byte

#(dotimes[x(count %1)](dotimes[y %2](prn(apply str(repeat %2(get %1 x))))))

Provalo online!

Non compresso:

#(dotimes [x (count %1)]
  (dotimes [y %2]
    (prn
      (apply str
        (repeat %2 (get %1 x))))))

Modifica: Elimina alcuni caratteri dalla fine sostituendo un ciclo for con la funzione di ripetizione stdlib.

C # (.NET Core) , 68 + 18 byte

a=>n=>new int[a.Length*n].Select((x,i)=>Enumerable.Repeat(a[i/n],n))

Incluso anche nel conteggio dei byte:

using System.Linq;

Provalo online!

L'output è una raccolta di raccolte di caratteri (una raccolta per ogni riga).

Spiegazione:

a => n =>                                // Take a string and a number
    new int[a.Length * n]                // Create new collection, 'n' times larger than 'a'
    .Select((x, i) =>                    // Replace every member with
        Enumerable.Repeat(a[i / n], n)   //     a collection of repeated character from 'a', based on index
    )