Aidez-moi! Mon appareil fonctionne mal et chaque fois que j'essaie de répéter une chaîne, j'obtiens des résultats en désordre. Au lieu de répéter la même chaîne N fois, il remplit un carré NxN avec chacun de ses caractères et empile les carrés.

Par exemple, étant donné la chaîne "Test"et le nombre 2, au lieu de "TestTest", j'obtiens:

TT
TT
ee
ee
ss
ss
tt
tt

Après avoir vu cela pendant un moment, j'ai commencé à l'aimer. Votre tâche aujourd'hui est de reproduire ce comportement étrange. Étant donné une chaîne non vide composée uniquement de caractères ASCII imprimables et un entier positif , affichez la chaîne renvoyée par mon périphérique défectueux.

• Toutes les règles standard s'appliquent.

• L'entrée et la sortie peuvent être traitées par tout moyen raisonnable.

• Il s'agit de code-golf , donc le code le plus court en octets dans chaque langue l'emporte.

Cas de test

Contribution 
Production

----------

"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

----------

Vous pouvez trouver un cas de test plus grand ici . Bonne chance et amusez-vous au golf!

Gelée , 4 octets

Inspiré par l'abus de gelée de M. Xcoder

x⁹×Y

Un programme complet prenant la chaîne et le nombre comme arguments de ligne de commande et affichant le résultat (car en tant que lien dyadique, il renvoie une liste de chaînes et de caractères de nouvelle ligne, ce qui peut ne pas être vraiment acceptable).

Essayez-le en ligne!

Comment?

Le cinq octets naïf (non abusif) est:

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'abus utilisé par M. Xcoder (Python operator.mulpeut agir sur un stret un intpour répéter les str- personnages ici simples - et l'atome qui l' utilise, ×, vectorises WRT son argument gauche) peut être utilisé ici aussi pour remplacer x€avec ×- ce qui donne le programme complet :

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

Gelée , 5 octets

C'est exactement ce qu'on nous demande de faire ... Abuser d'un comportement indéfini! *

×+⁷×⁴

Essayez-le en ligne!

^{* Par un comportement indéfini, je parle d'utiliser ×pour répéter des chaînes. Parfois, c'est un comportement plus court que d'habitude, alors pourquoi pas?}

Haskell , 26 octets

La fonction (!)renvoie une liste de lignes.

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

Essayez-le en ligne!

Bash + GNU Sed, 58

En utilisant une technique très similaire à cette réponse pour illustrer à quel point être dupe de cela , cette question est:

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

Essayez-le en ligne .

Husk , 5 4 octets

-1 octet grâce à @Zgarb

SṀRṘ

Essayez-le en ligne!

PowerShell , 31 octets

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

Essayez-le en ligne!

Explication:

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 octets

-2 octets grâce à scottinet

εײF=

Essayez-le en ligne!

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

Python 3 , 42 octets

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

Essayez-le en ligne!

MATL , 5 octets

t&Y"!

Essayez-le en ligne!

Explication

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 octets

-2 octets grâce à 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;}

Assurez-vous que la surcharge de l' +=opérateur appelé prend un chartype de données dans cette instructionif(!(i++%b))r+=10

Japt , 7 octets

Génère un tableau de chaînes.

VÆmpVÃy

Essayez-le ( -Rindicateur à des fins de visualisation uniquement)

Explication

Saisie implicite de chaîne Uet d'entier V.

VÆ    Ã

Générez un tableau d'entiers de 0à V-1et passez chacun par une fonction.

mpV

Mappez ( m) Uet répétez ( r) chaque Vfois le caractère .

y

Transpose et affiche implicitement le tableau résultant.

R , 59 octets

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

Écrit à stdout.

Divise la chaîne en caractères, se répète à chaque n^2fois, puis imprime avec largeur net sans séparateur.

Essayez-le en ligne!

J, ₁₅ 14 octets

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

Sous-optimal à coup sûr. Renvoie un tableau 2D de caractères. Prend ncomme argument gauche et la chaîne comme droite.

Sur mobile, les équipements habituels manquent donc.

Explication

(Pour l'ancienne réponse)

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

$"1 0 remodeler chaque caractère pour

(2#[)une n* nmatrice.

,/ joindre les matrices ensemble pour produire la sortie.

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

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

Essayez-le en ligne!

Pyth, 9 octets

VEp*+*NQb

Essayez-le ici!

Pyth, ₁₁ 10 octets

sm*Q+*QdbE

Essayez-le ici!

Ou, 10 octets:

jsm*Q]*QdE

Ou, 11 octets:

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

Fusain , 9 octets

ＦＳ«ＧTＩηι↓

Essayez-le en ligne!

Explication

ＦＳ         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 octets

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

Essayez-le en ligne (assurez-vous d'activer la mémoire dynamique sinon il ne fonctionnera pas)

Remarque: L'entrée est légèrement différente. Ce code prend une chaîne où le dernier caractère est un chiffre pour le nombre de répétitions. Donc, l'entrée pourrait ressembler Test5.

Ce code nécessite une bande illimitée et s'appuie sur le comportement d'encapsulation d'octets.

Non golfé:

,[>,]< 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 octets

∙ι*I

Cela a été fait pour un commit spécifique, à savoir celui avant que je ne change ∙, lorsqu'il est utilisé sur un tableau de chaînes, en répétant chaque lettre x fois pour répéter chaque élément x fois. Voici l'interpréteur en ligne sans cette version, qui, comme on peut le voir, ne fonctionne pas.

Pour essayer le commit, téléchargez -le , ouvrez le index.htmlfichier, dans le programme coller ∙ι*Iet dans l'entrée écrivez quelque chose comme

Test
2

Explication:

∙ι*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 118 100 octets

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

Essayez-le en ligne!

APL (Dyalog) , 8 octets

Prend la répétition comme argument de gauche et le texte comme argument de droite.

{⍺⌿⍺/⍪⍵}

Essayez-le en ligne!

{… } Un lambda sans nom où ⍺représente l'argument de gauche et ⍵l'argument de droite

 ⍪⍵ transformer le texte en un tableau à une colonne

 ⍺/ reproduire les ⍺temps horizontalement

 ⍺⌿ répliquer les ⍺temps verticalement

Japt , 7 octets

mpV² òV

Renvoie un tableau de chaînes.

Essayez-le en ligne! avec le -Rdrapeau pour rejoindre le tableau avec des sauts de ligne.

Explication

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 octets

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

Essayez-le en ligne!

Prend la chaîne comme argument de gauche et l'entier comme argument de droite. Il s'agit d'un portage de la réponse C ++ de HatsuPointerKun en D.

C (gcc) , 83 79 octets

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

Essayez-le en ligne!

CJam, 11 octets

{__*@e*/N*}

Fonction qui prend une chaîne suivie d'un int.

Essayez-le en ligne

Kotlin 1.1 - 99 octets

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

Renvoie la sortie entière sous forme de chaîne.

Impossible d'utiliser TryItOnline car 1.1 n'est pas pris en charge

Tester

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

Il serait de 84 si une liste de chaînes était acceptable en sortie:

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

PHP, 97 octets

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 octets

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

contribution

["Test", 4]

Pyth , 12 octets

Petit, mais je n'y suis pas encore arrivé.

VQp*+*Nszbsz

Explication:

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

Suite de tests

Clojure , 82 75 octets

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

Essayez-le en ligne!

Non compressé:

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

Edit: Rasé quelques caractères de la fin en remplaçant une boucle for par la fonction de répétition stdlib.

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

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

Également inclus dans le nombre d'octets:

using System.Linq;

Essayez-le en ligne!

La sortie est une collection de collections de caractères (une collection pour chaque ligne).

Explication:

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
    )