Un semplice pattino


17

ingressi:

Due cifre singole (chiamiamole me n) e due caratteri (chiamiamole ae b) nel formato di input desiderato.

Produzione:

Per la procedura dettagliata, fingere m=2, n=5, a='a', b='b'.

Il tuo output sarà una stringa creata dai tuoi quattro input. Chiamiamo la stringa result, con valore "". In primo luogo, concatenate asu result morari, in modo da concatenare asulle result 2volte. resultora è uguale aa. In secondo luogo, concatenate bsu result morari, in modo da concatenare bsulle result 2volte. resultora è uguale aabb. Infine, se il risultato è già più lungo di n, troncalo in resultmodo che abbia lunghezza n. Altrimenti, continua ad alternare con mcorse di lunghezza di ae bfino a quando non resultha lunghezza n. Il finale resultè aabba, che ha lunghezza 5.

Casi 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 

Come tutti sanno, uno minore governerà il mondo, quindi i programmi più piccoli, in byte, vincono! :)


Cosa intendi con "il carattere totale in output sarà 'n'" e "uno minore governerà il mondo"?
Erik the Outgolfer,

Fondamentalmente ho riscritto la sfida, mantenendo quello che credo fosse il tuo intento originale. Puoi eseguire il rollback se lo desideri, ma nel suo stato originale non verrà riaperto.
Stephen,

@StepHen mi hai salvato la giornata: p gracias :)
Durga,

@Durga nessun problema :) Sono contento che dica ancora quello che volevi.
Stephen,

2
@Durga ha proposto un caso di prova:m=2,n=10,a=A,b=B
Rod

Risposte:


8

Python , 32 byte

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

Provalo online!


Le funzioni anonime sono consentite l'ultima volta che ho controllato in modo da poter rimuovere f=per -2 byte.
Compagno SparklePony,

@ComradeSparklePony: Grazie per il testa a testa. Quello era rimasto del TiO; In realtà l'avevo già rimosso dal conteggio dei byte.
Julian Wolf,

2
È possibile inserire il f=nella sezione dell'intestazione di TIO, quindi non è necessario rimuoverlo manualmente. TIO
ovs,

Ah, mi dimentico sempre delle barre rovesciate. Grazie.
Julian Wolf,

1
A chiunque abbia suggerito la modifica (a*m+b*m)-> (a+b)*m: questo non funziona.
Julian Wolf,

6

MATL , 5 byte

Y"i:)

Gli input sono una stringa con i due caratteri, quindi m, quindi n.

Provalo online!

Spiegazione

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

Rubino, 29 caratteri

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

Esecuzione di esempio:

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

Provalo online!


5

Japt , 10 byte

VîUçW +UçX

Prima prova a usare un linguaggio da golf. Provalo online!

Spiegazione

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

Grazie per aver usato Japt, e ben fatto :-) Anche tu potresti fare VîWpU +XpU, ma entrambi fanno la stessa cosa. è perfetto per questa sfida.
ETHproductions

@ETHproductions Grazie e grazie per averlo fatto! Mi piace molto come tutto si traspone bene al codice JS.
Justin Mariner,

3

05AB1E , 5 byte

×J×I£

Provalo online!

Spiegazione

×      # repeat a and b m times each
 J     # join to string
  ×    # repeat the string n times
   I£  # take the first n characters

Esattamente quello che ho ottenuto senza prima controllare: P
Magic Octopus Urn


3

V , 13 byte

ÀäjÀäêÍî
À|lD

Provalo online!

ae bsono presi su righe separate nell'input me nsono presi come argomento, invertiti (così nè il primo argomento ed mè il secondo)

Spiegazione

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

Haskell , 36 35 29 byte

Ancora un'altra soluzione di Haskell (si aspetta che i personaggi siano elencati come un elenco):

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

Provalo online!

Grazie @Laikoni per -1 byte.


1
È possibile salvare un byte con (m#n)a b=.
Laikoni,

3

R , 41 39 byte

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

Una funzione anonima; stampa il risultato su stdout. Prende i personaggi come un vettore d=c(a,b). glgenera fattori (numeri interi) di (in questo caso) 2livelli di lunghezza della corsa mcon lunghezza totale n! catli concatena e li stampa come una stringa.

Provalo online!


Penso che function(d,m,n)rep(d,e=m,l=n)sarebbe una presentazione valida.
Ovs,

@ovs sfortunatamente repsi tradurrà in un vettore di caratteri piuttosto che in una singola stringa
Giuseppe

2

Javascript, 55 byte

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

Esempio di frammento di codice:

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 byte

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



1

QBIC , 37 27 byte

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

Spiegazione

          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

Tentativo precedente:

(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 byte

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

Provalo online!

guarda l'interprete

Accetta input come ab*m*ndove* può essere qualsiasi carattere non numerico.

Versione 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: leggi i caratteri e scambiali (così aè in cima)
  • I:q: leggi m, duplica e spingi verso il basso (lo stack è ora m,b,a,m)
  • ) : decremento
  • ? : gira a destra se positivo, vai dritto se zero (duplicati a )
  • ramo positivo (loop)
    • s:rur(/w: scambia, duplica, sposta m-iin cima alla pila, diminuiscem-i
  • ramo zero
    • B: Stack di inversione (che ora ha mle copie di a: a... b m)
    • n: negate m(quindi possiamo usare ?per girare a sinistra)
    • ) : incremento
    • ? : vai dritto se zero, gira a sinistra se negativo
  • ramo negativo (duplicati b)
    • s:r\/rw)\ sostanzialmente uguale al ramo positivo ma con incrementi e virate a sinistra.
  • ramo zero (stampa l'output)
    • >v;: espelle dallo 0stack (sembra a...b...)
    • /B : inverti la pila
    • I : leggere n
    • s : swap loop di stampa:
  • oq : stampa e spingi in fondo alla pila ora appare come: ab...a...n
  • ( diminuzione n
  • ? : girare a destra se positivo, andare dritto se zero
  • Se giusto,: /su scambia la parte superiore dello stack e continua il ciclo
  • se zero, /riflette verso il basso e il codice valutato è Iru@; @termina il programma.

0

Carbone , 10 byte

…⁺×ζIθ×εNN

Provalo online! Il collegamento è alla versione dettagliata del codice e include il quarto esempio. (Stranamente il deverbosifer non rimuoverà il separatore se ne aggiungo uno prima dell'ultimo InputNumber().)


Cosa intendi per separatore? (Puoi fare un esempio)
ASCII il

@ Solo ASCII Con la virgola prima dell'ultimo InputNumber (), nota che il codice generato ha un separatore non necessario: provalo online!
Neil,

0

Mathematica, 61 byte

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

ingresso

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


0

Mathematica, 44 byte

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

Spiegazione

è il carattere di uso privato a tre byte U+F3C7, che rappresenta l' \[Transpose]operatore postfix in Mathematica. Nessun collegamento TIO perché Mathics non supporta , \[Transpose]ha la precedenza dell'operatore errata, Tableè necessario che il secondo argomento sia un elenco e, soprattutto, StringPadRightnon sia implementato.

                                         & (* 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 byte

⎕⍴⎕/⎕

Provalo online!

Accetta i due caratteri in una stringa come primo input, seguito da me quindi n.

Spiegazione

Sia trattato all'ingresso esempio '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

Pyth , 13 byte

KE<*+*EQ*EQKK

Provalo online!

Spiegazione

                 # 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 byte

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

Provalo online!

Accetta l'input come una stringa di 4 caratteri. I primi due sono i personaggi a e b , seguiti dal valore di byte m , e quindi il valore di byte n . Ad esempio, il TIO include input ab<tab>2, questo corrisponde a 'a', 'b', 9, 50. (Poiché i codici per <tab>e2 sono 9 e 50.

Come?

Questa risposta è un po 'un colosso, ma ecco i punti salienti:

Il blocco superiore sinistro, con il minuscolo a- h, è il meccanismo di memorizzazione per i caratteri a e b , una linea per bit. In fondo, con v~ve mzè il meccanismo di commutazione, per scambiare tra i due.

Nel mezzo è una colonna con un gruppo di ~#M's. Questo recita in m e memorizza il suo negativo. Il grande triangolo a destra è solo fili per portare questo valore nell'accumulatore superiore.

Il blocco in alto a destra è l'accumulatore per m . Incrementa ogni ciclo (a partire da -m ) fino a raggiungere lo zero. In questo caso, il carattere di output viene scambiato e il conteggio riparte da -m .

Nel frattempo, c'è il blocco inferiore, che è l' accumulatore n . Poiché n viene letto solo una volta, non è necessario un banco di memoria ( Mem ) per memorizzare questo valore. Semplicemente lo neghiamo e iniziamo a contare. Quando questo valore raggiunge lo zero, l'intero shebang viene semplicemente terminato.

Tutti gli altri guff è ritardi ( Ze z), il cablaggio ( -, |, ...), e di altri miscellanea.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.