Un simple motif

17

Contributions:

Deux chiffres simples (appelons-les met n) et deux caractères (appelons-les aet b) dans le format d'entrée de votre choix.

Production:

Pour la procédure pas à pas, faites semblant m=2, n=5, a='a', b='b'.

Votre sortie sera une chaîne construite à partir de vos quatre entrées. Appelons la chaîne result, avec valeur "". D'abord, concaténer asur les result mtemps, donc concaténer asur les result 2temps. resultest maintenant égal à aa. En second lieu , concatenate bsur les result mtemps, donc concaténer bsur les result 2temps. resultest maintenant égal à aabb. Enfin, si le résultat est déjà plus long que n, tronquez resultpour qu'il ait une longueur n. Sinon, continuez d'alterner avec les mlongueurs de aet bjusqu'à ce que la resultlongueur ait n. La finale resultest aabba, qui a de la longueur 5.

Cas de test:

Input: m = 2, n = 4, a = A, b = B

Output: AABB

Input: m = 3, n = 8, a = A, b = B

Output: AAABBBAA

Input: m = 4, n = 3, a = A, b = B

Output: AAA

Input: m = 2, n = 10, a = A, b = B

Output: AABBAABBAA 

Comme tout le monde le sait, le moindre dirigera le monde, donc les plus petits programmes, en octets, gagneront! :)

Durga
la source
Qu'entendez-vous par «le nombre total de caractères en sortie sera« n »» et «moins un gouvernera le monde»?
Erik the Outgolfer
J'ai essentiellement réécrit le défi, en gardant ce que je croyais être votre intention initiale. Vous pouvez annuler si vous le souhaitez, mais dans son état d'origine, il ne sera pas rouvert.
Stephen
@StepHen vous avez sauvé ma journée: p gracias :)
Durga
@Durga pas de problème :) Je suis content que ça dise toujours ce que tu voulais.
Stephen
2
@Durga a proposé un scénario de test:m=2,n=10,a=A,b=B
Rod

Réponses:

8

Python , 32 octets

lambda m,n,a,b:((a*m+b*m)*n)[:n]

Essayez-le en ligne!

Julian Wolf
la source
Les fonctions anonymes sont autorisées en dernier, j'ai vérifié afin que vous puissiez supprimer le f=pour -2 octets.
Camarade SparklePony
@ComradeSparklePony: Merci pour l'avertissement. Cela restait du TiO; Je l'avais en fait déjà supprimé du nombre d'octets.
Julian Wolf
2
Vous pouvez mettre le f=dans la section d'en-tête de TIO, vous n'avez donc pas besoin de le supprimer manuellement. TIO
ovs
Ah, j'oublie toujours les contre-obliques. Merci.
Julian Wolf
1
À qui a suggéré de modifier (a*m+b*m)-> (a+b)*m: cela ne fonctionne pas.
Julian Wolf
6

MATL , 5 octets

Y"i:)

Les entrées sont une chaîne avec les deux caractères, puis m, alors n.

Essayez-le en ligne!

Explication

Y"   % Implicit inputs: string and number m. Apply run-length decoding.
     % The second input is reused for each char in the first. Gives a
     % string
i    % Input number n
:    % Push vector [1 2 ... n]
)    % Index the string with the numbers in that vector. Indexing is
     % modular, so the chars are reused if necessary. Implicit display
Luis Mendo
la source
5

Ruby, 29 caractères

->m,n,a,b{((a*m+b*m)*n)[0,n]}

Exemple d'exécution:

irb(main):001:0> ->m,n,a,b{((a*m+b*m)*n)[0,n]}[3, 8, 'A', 'B']
=> "AAABBBAA"

Essayez-le en ligne!

homme au travail
la source
5

Japt , 10 octets

VîUçW +UçX

Essayez d'abord d'utiliser une langue de golf. Essayez-le en ligne!

Explication

Vî          // repeat the following until it reaches length V (second input)
  UçW       // third input repeated U (first input) times
      +UçX  // plus the fourth input, repeated U times
Justin Mariner
la source
Merci d'avoir utilisé Japt, et bien joué :-) Vous pourriez VîWpU +XpUaussi le faire , mais les deux font la même chose. est parfait pour ce défi.
ETHproductions
@ETHproductions Merci et merci de l'avoir fait! J'apprécie vraiment la façon dont tout transpile bien au code JS.
Justin Mariner
3

05AB1E , 5 octets

×J×I£

Essayez-le en ligne!

Explication

×      # repeat a and b m times each
 J     # join to string
  ×    # repeat the string n times
   I£  # take the first n characters
Emigna
la source
Exactement ce que j'ai obtenu sans vérifier d'abord: P
Urne de poulpe magique
3

V , 13 octets

ÀäjÀäêÍî
À|lD

Essayez-le en ligne!

aet bsont prises sur des lignes distinctes dans l'entrée, met nsont prises comme argument, inversées (tout ncomme le premier argument et mle deuxième)

Explication

Àäj      ' duplicate the inputs [arg 1] times
a -> a
b    b
     a
     b
     ...
   Àäê   ' duplicate everything straight down [arg 2] times - À cycles arguments
a -> aaa
b    bbb
a    aaa
b    bbb
...  ...
      Íî ' remove all newlines
-> aaabbbaaabbb...
À|lD     ' delete from the [arg 1] + 1 column onwards
-> aaabbbaa
nmjcman101
la source
3

Haskell , 36 35 29 octets

Encore une autre solution Haskell (attend les caractères donnés sous forme de liste):

(m#n)c=take n$cycle$c<*[1..m]

Essayez-le en ligne!

Merci @Laikoni pour -1 octet.

ბიმო
la source
1
Vous pouvez enregistrer un octet avec (m#n)a b=.
Laikoni
3

R , 41 39 octets

function(d,m,n)cat(d[gl(2,m,n)],sep='')

Une fonction anonyme; imprime le résultat sur stdout. Prend les personnages comme vecteur d=c(a,b). glgénère des facteurs (entiers) de (dans ce cas) des 2niveaux de longueur de course mavec la longueur totale n! catles concatène et les imprime sous forme de chaîne.

Essayez-le en ligne!

Giuseppe
la source
Je pense que ce function(d,m,n)rep(d,e=m,l=n)serait un argument valable.
2017
@ovs donnera malheureusement repun vecteur de caractères plutôt qu'une seule chaîne
Giuseppe
2

Javascript, 55 octets

(m,n,a,b)=>(a[r='repeat'](m)+b[r](m))[r](n).substr(0,n)

Exemple d'extrait de code:

f=

(m,n,a,b)=>(a[r='repeat'](m)+b[r](m))[r](n).substr(0,n)

console.log(f(2, 4, 'A', 'B'))
console.log(f(3, 8, 'A', 'B'))
console.log(f(4, 3, 'A', 'B'))
console.log(f(2, 9, 'A', 'B'))

Herman L
la source
2

Javascript, 53 octets

(m,n,a,b)=>a.repeat(n).replace(/./g,(i,j)=>j/m&1?b:i)
Ra8
la source
1

QBIC , 37 27 octets

[:|G=;+G+;][:|G=G+G]?_sG,d

Explication

          This takes its arguments as frequency m, A, B, length n
          For example: 2, A, B, 8
 :        Read a cmd line arg as number 'b' ('a' is used by the FOR declaration as loop counter)
[ |       Start a FOR loop, from 1 to b
G=  G     Set G to hold itself
  ;+      prepended by a cmd line arg read as strig and assigned to A$
     +;   and followed by a cmd line arg read as strig and assigned to B$
]         At the end of the FOR loop, G has had A added to the front twice, and B t the end x2: G$ = AABB
[:|       FOR c = 1 to n
G=G+G]      Add G to itself          G$ = AABBAABBAABBAABBAABBAABBAABBAABB
?_sG,d    PRINT the first n chars of G$   AABBAABB

Tentative précédente:

(37b)  {Z=Z+;┘_LZ|~a=:|_X]~a%:|\C=A┘A=;┘B=C
Takes its arguments as `A, length n, frequency m, B`.
Basically adds A to Z until length % freq = 0, then swaps A for B. Loops until lengtn = n
steenbergh
la source
1

PHP> = 7.1, 77 octets

for([,$x,$l,$f,$s]=$argv;$l-=$z;)echo str_repeat(++$i&1?$f:$s,$z=min($l,$x));

PHP Sandbox Online

Jörg Hülsermann
la source
1

Cubix , 63 58 octets

.rr.@u:s?.\.sw).i|>v:.\nB;?(q:Is...;rr/s.uw/....sIB/\/?(qo

Essayez-le en ligne!

regarder l'interprète

Prend une entrée comme ab*m*noù le *peut être n'importe quel caractère non numérique.

Version du cube:

        . r r .
        @ u : s
        ? . \ .
        s w ) .
i | > v : . \ n B ; ? ( q : I s
. . . ; r r / s . u w / . . . .
s I B / \ / ? ( q o . . . . . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .
  • i|is: lisez les caractères et échangez-les (donc ac'est en haut)
  • I:q: lire m, copier et pousser vers le bas (la pile est maintenant m,b,a,m)
  • ) : décrémenter
  • ?: tourner à droite si positif, aller tout droit si zéro (doublons a)
  • branche positive (boucle)
    • s:rur(/w: swap, dup, déplacer m-ivers le haut de la pile, décrémenterm-i
  • branche zéro
    • B: pile inverse (qui a maintenant des mcopies de a:a... b m )
    • n: nier m(afin que nous puissions utiliser ?pour tourner à gauche)
    • ) : incrément
    • ? : aller tout droit si zéro, tourner à gauche si négatif
  • branche négative (doublons b)
    • s:r\/rw)\ essentiellement la même que la branche positive mais avec incrément et virages à gauche.
  • branche zéro (imprime la sortie)
    • >v;: sortez la 0pile (ressemble a...b...)
    • /B : inverser la pile
    • I : lis n
    • s : permuter la boucle d'impression:
  • oq : imprimer et pousser vers le bas de la pile ressemble maintenant à: ab...a...n
  • ( décrémenter n
  • ? : tourner à droite si positif, aller tout droit si zéro
  • Si c'est le cas,:: /suéchange le haut de la pile et continue la boucle
  • si zéro, se /reflète vers le bas et le code évalué est Iru@; @termine le programme.
Giuseppe
la source
0

Fusain , 10 octets

…⁺×ζIθ×εNN

Essayez-le en ligne! Le lien est vers la version détaillée du code et inclut le quatrième exemple. (Malheureusement, le deverbosifer ne supprimera pas le séparateur si j'en ajoute un avant le dernier InputNumber().)

Neil
la source
Qu'entendez-vous par le séparateur? (Pouvez-vous donner un exemple)
ASCII uniquement le
@ ASCII uniquement Avec la virgule avant le dernier InputNumber (), notez que le code généré a un séparateur inutile: Essayez-le en ligne!
Neil
0

Mathematica, 61 octets

T=Table;StringTake[""<>Flatten@T[{#3~T~#,#4~T~#},⌈#2/#⌉],#2]&

contribution

[2,10, "A", "B"]

J42161217
la source
0

Mathematica, 44 octets

StringPadRight[x={##3}~Table~#<>"",#2,x]&

Explication

est le caractère à usage privé de trois octets U+F3C7, représentant l' \[Transpose]opérateur postfix dans Mathematica. Aucun lien TIO car Mathics ne prend pas en charge , \[Transpose]a la mauvaise priorité d'opérateur, le deuxième argument de Tabledoit être une liste et, surtout, StringPadRightn'est pas implémenté.

                                         & (* Function *)
                 {##3}                     (* which takes the third and fourth arguments *)
                      ~Table~#             (* repeats them a number of times equal to the first argument *)
                                          (* takes the tranpose *)
                               <>""        (* then joins the strings with the empty string *)
               x=                          (* sets x equal to that string *)
StringPadRight[                            (* then pads x *)
                                   ,#2     (* to a length equal to the second argument *)
                                      ,x]  (* with x. *)
ngenisis
la source
0

APL (Dyalog) , 5 octets

⎕⍴⎕/⎕

Essayez-le en ligne!

Prend les deux caractères dans une chaîne comme première entrée, suivi mpuisn .

Explication

Laissez l'entrée par exemple être 'ab', 2, 10.

⎕/⎕                 Replicate the two-char string `m` times
                    2/'ab' => 'aabb'
⎕⍴                  Shape it so that its length is `n`
                    10'aabb' => 'aabbaabbaa'
Kritixi Lithos
la source
0

Pyth , 13 octets

KE<*+*EQ*EQKK

Essayez-le en ligne!

Explication

                 # Implicitly store m to Q
KE               # Store n to K
     *EQ         # Perform a * m
        *EQ      # Perform b * m
    +            # Concatenate the two strings
   *       K     # Multiply by n
  <         K    # Take the first n characters of the string
Jim
la source
0

Puce , 588 octets

*Z~vZ.*ZZZs  z. z. z. z. z. z. z. z.
  ,'|`-. ZZ--#<,#<,#<,#<,#<,#<,#<,#<
a/mAM/a| `~S `x'`x'`x'`x'`x'`x'`x'`x.
b/mBM/b|  *.)/')/')/')/')/')/')/')/'|
c/mCM/cZv--x^x-^x-^x-^x-^x-^x-^x-^x-'
d/mDM/d||A~#M',-',-',-',-',-',-',-'
e/mEM/e||B~#M-',-',-',-',-',-',-'
f/mFM/f||C~#M--',-',-',-',-',-'
g/mGM/g||D~#M---',-',-',-',-'
h/mHM/h||E~#M----',-',-',-'
 `v~v' ||F~#M-----',-',-'
* `mz  ||G~#M------',-'
Z  `---x'H~#M-------'
Z,--z--^----'
Z|z. z. z. z. z. z. z. z.
Zx#<,#<,#<,#<,#<,#<,#<,#<
 |`x'`x'`x'`x'`x'`x'`x'`xT
 |A| B| C| D| E| F| G| H|
 )\')\')\')\')\')\')\')\'
 `--^--^--^--^--^--^--'

Essayez-le en ligne!

Prend l'entrée comme une chaîne de 4 caractères. Les deux premiers sont les caractères a et b , suivis de la valeur d'octet m , puis de la valeur d'octet n . Par exemple, le TIO comprend une entrée ab<tab>2, cela correspond à «a», «b», 9, 50 (puisque les codes pour <tab>et 2sont 9 et 50.

Comment?

Cette réponse est un peu géante, mais voici les points saillants:

Le bloc supérieur gauche, avec les minuscules a- h, est le mécanisme de stockage des caractères a et b , une ligne par bit. Au fond, avec le v~vet mzest le mécanisme de commutation, pour permuter entre les deux.

Au milieu se trouve une colonne avec un tas de ~#M. Cela se lit en m et stocke son négatif. Le grand triangle à droite n'est que des fils pour amener cette valeur dans l'accumulateur supérieur.

Le bloc supérieur droit est l'accumulateur pour m . Il incrémente chaque cycle (à partir de -m ) jusqu'à ce qu'il atteigne zéro. Lorsque cela se produit, le caractère de sortie est échangé et le comptage redémarre à partir de -m .

Pendant ce temps, il y a le bloc inférieur, qui est l' accumulateur n . Puisque n n'est lu qu'une seule fois, nous n'avons pas besoin d'une banque de mémoire ( Met m) pour stocker cette valeur. Nous le nions simplement et commençons à compter. Lorsque cette valeur atteint zéro, tout le shebang est simplement terminé.

Tous les autres Guff est des retards ( Zet z), le câblage ( -, |, ...), et d' autres miscellany.

Phlarx
la source