Um padrão simples


17

Entradas:

Dois únicos dígitos (chamá-los de deixar me n) e dois caracteres (vamos chamá-los ae b) no seu formato de entrada de escolha.

Resultado:

Para o passo a passo, finja m=2, n=5, a='a', b='b'.

Sua saída será uma string criada a partir de suas quatro entradas. Vamos chamar a string result, com valor "". Primeiro, concatene anos result mhorários, portanto concatene anos result 2horários. resultagora é igual aa. Segundo, concatene bnos result mhorários, portanto concatene bnos result 2horários. resultagora é igual aabb. Por fim, se o resultado já for maior que n, trunque resultpara que ele tenha comprimento n. Caso contrário, continue alternando com mtrechos de comprimento de ae baté que ele resulttenha comprimento n. A final resulté aabba, que tem duração 5.

Casos de teste:

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 sabem, um menor governará o mundo, e os menores programas, em bytes, vencem! :)


O que você quer dizer com "char total na produção será 'n'" e "menor será o dono do mundo"?
Erik the Outgolfer

Eu basicamente reescrevi o desafio, mantendo o que acredito ser sua intenção original. Você pode reverter, se quiser, mas no estado original, não será reaberto.
Stephen

@StepHen você salvou o meu dia: p gracias :)
Durga

@ Durga não há problema :) Fico feliz que ainda diz o que você queria.
Stephen

2
O @Durga propôs o caso de teste:m=2,n=10,a=A,b=B
Rod

Respostas:


8

Python , 32 bytes

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

Experimente online!


As funções anônimas são permitidas pela última vez que verifiquei, para que você possa remover os f=bytes de -2.
precisa saber é o seguinte

@ComradeSparklePony: Obrigado pela atenção. Isso foi o que restou do TiO; Na verdade, eu já o havia removido da contagem de bytes.
Julian Lobo

2
Você pode colocá-lo f=na seção de cabeçalho do TIO, para não precisar removê-lo manualmente. TIO
ovs 6/07/07

Ah, eu sempre esqueço barras invertidas. Obrigado.
Julian Lobo

11
Para quem sugeriu a edição (a*m+b*m)-> (a+b)*m: isso não funciona.
Julian Lobo

6

MATL , 5 bytes

Y"i:)

Entradas são uma sequência com os dois caracteres, então m, então n.

Experimente online!

Explicação

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



5

Japonês , 10 bytes

VîUçW +UçX

Primeiro tente usar uma linguagem de golfe. Experimente online!

Explicação

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

Obrigado por usar o Japt, e bem feito :-) Você poderia fazer VîWpU +XpUtambém, mas ambos fazem a mesma coisa. é perfeito para esse desafio.
ETHproductions

@ETHproductions Obrigado e obrigado por fazer isso! Eu realmente gosto de como tudo transpila bem para o código JS.
Justin Mariner



3

V , 13 bytes

ÀäjÀäêÍî
À|lD

Experimente online!

ae bsão tomados em linhas separadas na entrada me ntomados como argumento, invertidos (assim ncomo o primeiro argumento em o segundo)

Explicação

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


3

R , 41 39 bytes

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

Uma função anônima; imprime o resultado em stdout. Toma os caracteres como um vetor d=c(a,b). glgera fatores (inteiros) de (neste caso) 2níveis de duração de execução mcom duração total n! catconcatena e os imprime como uma sequência.

Experimente online!


Eu acho function(d,m,n)rep(d,e=m,l=n)que seria uma apresentação válida.
ovs 08/07/19

@ovs infelizmente repirá resultar em um vetor de caracteres em vez de uma única corda
Giuseppe

2

Javascript, 55 bytes

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

Exemplo de trecho de código:

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


2

Javascript, 53 bytes

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



1

QBIC , 37 27 bytes

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

Explicação

          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

Tentativa anterior:

(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



1

Cubix , 63 58 bytes

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

Experimente online!

assista ao intérprete

Toma entrada como ab*m*n onde* pode ser qualquer caractere que não seja um dígito.

Versão do 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: leia os caracteres e troque-os (assim aestá no topo)
  • I:q: leia m, duplique e empurre para baixo (a pilha está agora m,b,a,m)
  • ) : decrement
  • ? : vire à direita se positivo, siga em frente se zero (duplicatas a )
  • ramo positivo (loop)
    • s:rur(/w: swap, dup, vá m-ipara o topo da pilha, diminuam-i
  • ramo zero
    • B: Pilha inversa (que agora tem mcópias de a: a... b m)
    • n: negar m(para que possamos usar ?para virar à esquerda)
    • ) : incremento
    • ? : siga em frente se for zero, vire à esquerda se for negativo
  • ramo negativo (duplicatas b)
    • s:r\/rw)\ basicamente o mesmo que o ramo positivo, mas com incrementos e curvas à esquerda.
  • ramo zero (imprime a saída)
    • >v;: 0retire a pilha (parecea...b... )
    • /B : inverter a pilha
    • I : ler n
    • s : troca de loop de impressão:
  • oq : imprima e empurre para o final da pilha agora se parece com: ab...a...n
  • ( diminuir n
  • ? : vire à direita se positivo, siga em frente se zero
  • Se estiver certo: /su ::: troque a parte superior da pilha e continue o loop
  • se zero, /reflete para baixo e o código avaliado é Iru@; @finaliza o programa.

0

Carvão , 10 bytes

…⁺×ζIθ×εNN

Experimente online! Link é uma versão detalhada do código e inclui o quarto exemplo. (Irritantemente, o deverbosifer não removerá o separador se eu adicionar um antes do último InputNumber().)


O que você quer dizer com separador? (Você pode dar um exemplo)
somente ASCII

@ Somente ASCII Com a vírgula antes do último InputNumber (), observe que o código gerado possui um separador desnecessário: Experimente online!
274 Neil

0

Mathematica, 61 bytes

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

entrada

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


0

Mathematica, 44 bytes

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

Explicação

é o caractere de uso privado de três bytes U+F3C7, representando o \[Transpose]operador postfix no Mathematica. Nenhum link TIO porque o Mathics não suporta , \[Transpose]tem a precedência errada do operador, o segundo argumento para Tableé necessário para ser uma lista e, o mais importante, StringPadRightnão é 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. *)

0

APL (Dyalog) , 5 bytes

⎕⍴⎕/⎕

Experimente online!

Leva os dois caracteres em uma sequência como a primeira entrada, seguida por me depois n.

Explicação

Deixe a entrada exemplo ser 'ab', 2, 10.

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

0

Pitão , 13 bytes

KE<*+*EQ*EQKK

Experimente online!

Explicação

                 # 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


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

Experimente online!

Recebe a entrada como uma sequência de 4 caracteres. Os dois primeiros são os caracteres a e b , seguindo-se o valor de byte m , e, em seguida, o valor do byte n . Por exemplo, o TIO inclui entrada ab<tab>2, isso corresponde a 'a', 'b', 9, 50. (Como os códigos para <tab>e 2são 9 e 50.

Quão?

Esta resposta é um pouco gigante, mas aqui estão os destaques:

O bloco de canto superior esquerdo, com o minúsculas a- h, é o mecanismo de armazenamento para os caracteres de um e b , uma linha por bit. Na parte inferior, com v~ve mzé o mecanismo de comutação, para alternar entre os dois.

No meio é uma coluna com um monte de ~#M's. Isto lê em m e armazena a sua negativa. O grande triângulo à direita são apenas fios para trazer esse valor para o acumulador superior.

O bloco superior direito é o acumulador para m . Incrementa cada ciclo (a partir de -m ) até chegar a zero. Quando isso acontece, o caractere de saída é trocado e a contagem é reiniciada a partir de -m .

Enquanto isso, existe o bloco inferior, que é o n acumulador. Desde n é lido apenas uma vez, não precisamos de um banco de memória ( Me m) para armazenar esse valor. Simplesmente negamos e começamos a contar. Quando esse valor chega a zero, o shebang inteiro é simplesmente encerrado.

Todo o resto de bobagens são atrasos (Z e z), a fiação ( -, |...), e outra miscelânea.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.