Un patrón simple

17

Entradas:

Dos dígitos individuales (llamémoslos my n) y dos caracteres (llamémoslos ay b) en el formato de entrada de su elección.

Salida:

Para el tutorial, finja m=2, n=5, a='a', b='b'.

Su salida será una cadena construida a partir de sus cuatro entradas. Llamemos a la cadena result, con valor "". Primero, concatene aen result mtiempos, así que concatene aen result 2tiempos. resultAhora es igual aa. En segundo lugar, concatene ben result mtiempos, así que concatene ben result 2tiempos. resultAhora es igual aabb. Por último, si el resultado ya es más largo que n, truncar resultpara que tenga longitud n. De lo contrario, continúe alternando con mcarreras de longitud de ay bhasta que resulttenga longitud n. El final resultes aabba, que tiene longitud 5.

Casos de prueba:

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 

Como todos saben, uno menor gobernará el mundo, por lo que los programas más pequeños, en bytes, ¡ganan! :)

Durga
fuente
¿Qué quiere decir con "char total en la producción será 'n'" y "uno menor gobernará el mundo"?
Erik the Outgolfer
Básicamente reescribí el desafío, manteniendo lo que creo que fue tu intención original. Puede revertir si lo desea, pero en su estado original no se va a volver a abrir.
Stephen
@StepHen me salvaste el día: p gracias :)
Durga
@Durga no hay problema :) Me alegro de que todavía diga lo que querías.
Stephen
2
@Durga caso de prueba propuesto:m=2,n=10,a=A,b=B
Rod

Respuestas:

8

Python , 32 bytes

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

Pruébalo en línea!

Julian Wolf
fuente
Las funciones anónimas están permitidas la última vez que las verifiqué para que pueda eliminar las f=de -2 bytes.
Camarada SparklePony
@ComradeSparklePony: Gracias por el aviso. Eso fue lo que sobró del TiO; De hecho, ya lo había eliminado del recuento de bytes.
Julian Wolf
2
Puede ponerlo f=en la sección de encabezado de TIO, por lo que no necesita eliminarlo manualmente. TIO
ovs
Ah, siempre me olvido de las barras invertidas. Gracias.
Julian Wolf
1
Para quien sugirió editar (a*m+b*m)-> (a+b)*m: esto no funciona.
Julian Wolf
6

MATL , 5 bytes

Y"i:)

Las entradas son una cadena con los dos caracteres, luego m, luego n.

Pruébalo en línea!

Explicación

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
fuente
5

Ruby, 29 caracteres

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

Ejecución de muestra:

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

Pruébalo en línea!

hombre trabajando
fuente
5

Japt , 10 bytes

VîUçW +UçX

Primero intente usar un lenguaje de golf. Pruébalo en línea!

Explicación

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
fuente
Gracias por usar Japt, y bien hecho :-) También podrías hacerlo VîWpU +XpU, pero ambos hacen lo mismo. Es perfecto para este desafío.
ETHproductions
@ETHproductions ¡Gracias y gracias por hacerlo! Realmente disfruto cómo todo se transmite muy bien al código JS.
Justin Mariner
3

05AB1E , 5 bytes

×J×I£

Pruébalo en línea!

Explicación

×      # repeat a and b m times each
 J     # join to string
  ×    # repeat the string n times
   I£  # take the first n characters
Emigna
fuente
Exactamente lo que obtuve sin verificar primero: P
Urna de pulpo mágico
3

V , 13 bytes

ÀäjÀäêÍî
À|lD

Pruébalo en línea!

ay bse toman en líneas separadas en la entrada, my nse toman como argumento, invertidos (así nes el primer argumento y mes el segundo)

Explicación

Àä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
fuente
3

Haskell , 36 35 29 bytes

Otra solución más de Haskell (espera los caracteres dados como una lista):

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

Pruébalo en línea!

Gracias @Laikoni por -1 byte.

ბიმო
fuente
1
Puede guardar un byte con (m#n)a b=.
Laikoni
3

R , 41 39 bytes

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

Una función anónima; imprime el resultado en stdout. Toma los personajes como un vector d=c(a,b). gl¡genera factores (enteros) de (en este caso) 2niveles de longitud de ejecución mcon longitud total n! catlos concatena y los imprime como una cadena.

Pruébalo en línea!

Giuseppe
fuente
Creo que function(d,m,n)rep(d,e=m,l=n)sería una presentación válida.
ovs
@ovs desafortunadamente repdará como resultado un vector de caracteres en lugar de una sola cadena
Giuseppe
2

Javascript, 55 bytes

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

Fragmento de código de ejemplo:

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

Javascript, 53 bytes

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

Casco , 3 bytes

Puerto directo de mi respuesta de Haskell, excepto que el orden de los argumentos es diferente:

↑¢Ṙ

Pruébalo en línea!

ბიმო
fuente
1

QBIC , 37 27 bytes

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

Explicación

          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

Intento previo:

(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
fuente
1

PHP> = 7.1, 77 bytes

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

PHP Sandbox en línea

Jörg Hülsermann
fuente
1

Cubix , 63 58 bytes

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

Pruébalo en línea!

mira al intérprete

Toma datos como ab*m*ndonde el* puede haber cualquier carácter sin dígitos.

Versión de cubo:

        . 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: lea los caracteres y cámbielos (también aestá en la parte superior)
  • I:q: leer m, duplicar y presionar hacia abajo (la pila está ahora m,b,a,m)
  • ) : decremento
  • ?: gire a la derecha si es positivo, vaya derecho si es cero (duplicados a)
  • rama positiva (bucle)
    • s:rur(/w: intercambiar, dup, mover m-ia la parte superior de la pila, disminuirm-i
  • rama cero
    • B: pila inversa (que ahora tiene mcopias de a:a... b m )
    • n: negar m(para que podamos usar ?para girar a la izquierda)
    • ) : incremento
    • ? : siga recto si es cero, gire a la izquierda si es negativo
  • rama negativa (duplicados b)
    • s:r\/rw)\ básicamente lo mismo que la rama positiva pero con incrementos y giros a la izquierda.
  • rama cero (imprime la salida)
    • >v;: abre la 0pila (parece a...b...)
    • /B : invertir la pila
    • I : leer n
    • s : intercambiar bucle de impresión:
  • oq : imprimir y empujar al fondo de la pila ahora se ve así: ab...a...n
  • ( decremento n
  • ? : gire a la derecha si es positivo, vaya derecho si es cero
  • Si es correcto: /su intercambie la parte superior de la pila y continúe el ciclo
  • si es cero, se /refleja hacia abajo y el código evaluado es Iru@; @termina el programa
Giuseppe
fuente
0

Carbón de leña , 10 bytes

…⁺×ζIθ×εNN

Pruébalo en línea! El enlace es a una versión detallada del código e incluye el cuarto ejemplo. (Molesto, el deverbosifer no eliminará el separador si agrego uno antes del último InputNumber()).

Neil
fuente
¿Qué quieres decir con separador? (¿Puedes dar un ejemplo?)
ASCII solo el
@ Solo ASCII Con la coma antes del último InputNumber (), observe que el código generado tiene un separador innecesario: ¡ Pruébelo en línea!
Neil
0

Mathematica, 61 bytes

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

entrada

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

J42161217
fuente
0

Mathematica, 44 bytes

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

Explicación

es el carácter de uso privado de tres bytes U+F3C7, que representa el \[Transpose]operador postfix en Mathematica. No hay un enlace TIO porque Mathics no es compatible , \[Transpose]tiene una prioridad de operador incorrecta, el segundo argumento Tabledebe ser una lista y, lo más importante, StringPadRightno está implementado.

                                         & (* 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
fuente
0

APL (Dyalog) , 5 bytes

⎕⍴⎕/⎕

Pruébalo en línea!

Toma los dos caracteres en una cadena como la primera entrada, seguido de my luego n.

Explicación

Sea la entrada de ejemplo '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
fuente
0

Pyth , 13 bytes

KE<*+*EQ*EQKK

Pruébalo en línea!

Explicación

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

Chip , 588 bytes

*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|
 )\')\')\')\')\')\')\')\'
 `--^--^--^--^--^--^--'

Pruébalo en línea!

Toma la entrada como una cadena de 4 caracteres. Los dos primeros son los personajes a y b , seguido por el valor de byte m , y luego el valor de byte n . Por ejemplo, el TIO incluye entrada ab<tab>2, esto corresponde a 'a', 'b', 9, 50. (Dado que los códigos para <tab>y 2son 9 y 50.

¿Cómo?

Esta respuesta es un poco gigantesca, pero aquí están los aspectos más destacados:

El bloque superior izquierda, con la minúscula a- h, es el mecanismo de almacenamiento para los caracteres a y b , una línea por bit. En su parte inferior, con el v~vymz es el mecanismo de conmutación, para intercambiar entre los dos.

En el medio hay una columna con un montón de ~#M's. Esto se lee en m almacena su negativo. El gran triángulo a la derecha es solo cables para llevar este valor al acumulador superior.

El bloque superior derecho es el acumulador para m . Incrementa cada ciclo (comenzando desde -m ) hasta llegar a cero. Cuando esto sucede, el carácter de salida se intercambia y el recuento se reinicia desde -m .

Mientras tanto, está el bloque inferior, que es el n acumulador. Como n solo se lee una vez, no necesitamos un banco de memoria ( My m) para almacenar este valor. Simplemente lo negamos y comenzamos a contar. Cuando este valor llega a cero, todo el shebang simplemente termina.

Todo lo demás es retrasos ( Zy z), cableado (- , |, ...), y otra miscelánea.

Phlarx
fuente