Giocoleria per numeri

Il tuo compito è generare un modello di giocoleria valido completando un determinato modello. Ma prima, probabilmente devi sapere come viene indicato un tale schema.

Introduzione a Siteswap

Siteswap è la notazione consolidata per i modelli di giocoleria. Funziona dividendo il pattern in beat. Ad ogni battito la mano sinistra e destra si alternano al lancio di una palla. Ogni lancio (ovvero ogni battito) è indicato da un numero che indica quando viene lanciata la palla successiva - questo corrisponde direttamente all'altezza del tiro.

Diamo un'occhiata ad alcuni esempi. Guarda le animazioni di tutti questi qui .

Cascata a 3 sfere

Il modello a 3 palle più semplice. Ogni palla viene lanciata ad ogni terzo battito (mani alternate). Scrivendo i battiti questo appare come segue (le linee ASCII collegano due battiti a cui viene lanciata la stessa palla):

Beat     1 2 3 4 5 6 7 8 9
Hand     L R L R L R L R L
Siteswap 3 3 3 3 3 3 3 3 3
         └─┼─┼─┘ │ │
           └─┼───┘ │
             └─────┘

Nota come ogni palla lanciata in un Lbattito, viene lanciata successivamente in un Rbattito. I modelli di scambio si ripetono implicitamente, quindi questo modello è generalmente indicato come 333, anche se semplicemente 3sarebbe sufficiente.

441

Ecco un esempio leggermente più complicato con il sitewap 441 :

Beat     1 2 3 4 5 6 7 8 9
Hand     L R L R L R L R L
Siteswap 4 4 1 4 4 1 4 4 1
         │ │ └─┘ │ │
         └─┼─────┘ │
           └───────┘

Nota come i tiri con numero pari vanno alla stessa mano da cui sono stati lanciati, mentre i tiri con numero dispari vanno all'altra mano.

423

A volte vuoi solo tenere una palla attraverso un battito invece di lanciarla. Tutto ciò significa che questa palla viene lanciata la prossima volta che è il turno di questa mano, ovvero 2 battiti dopo. Quindi tenere una palla equivale a a 2nel modello:

Beat     1 2 3 4 5 6 7 8 9
Hand     L R L R L R L R L
Siteswap 4 2 3 4 2 3 4 2 3
         │ └─┼─┘ │ │
         │   └───┼─┘
         └───────┘

50505

A 0significa che la mano corrente è vuota in quel battito, come mostra questo schema:

Beat     1 2 3 4 5 6 7 8 9
Hand     L R L R L R L R L
Siteswap 5 0 5 0 5 5 0 5 0
         └───┼───┼─┘   │
             └───┼─────┘
                 └───────>

Giocoleria multiplex

Tuttavia, questo problema sarebbe un po 'troppo semplice con i siti di vaniglia. Inserisci modelli multiplex! La giocoleria multipla significa che lanci più palline da una mano contemporaneamente. Ad esempio, nella precedente cascata a 3 palline, se eri in due a lanciare una pallina aggiuntiva ad ogni terzo battito, lo schema diventerebbe [33]33e apparirebbe così:

Beat     1    2 3 4    5 6 7    8 9
Hand     L    R L R    L R L    R L
Siteswap [33] 3 3 [33] 3 3 [33] 3 3
          └┴──┼─┼──┴┘  │ │
              └─┼──────┘ │
                └────────┘

Ecco un altro esempio, in cui il lancio multiplex ha due diverse altezze / lunghezze. Potrebbe essere indicato come uno [34]11o [43]11:

Beat     1    2 3 4    5 6 7    8 9
Hand     L    R L R    L R L    R L
Siteswap [43] 1 1 [43] 1 1 [43] 1 1
          ││  └─┴──┘│  │
          │└────────┘  │
          └────────────┘

(Notare che il 1lancio a battuta 2atterra a battuta 3e viene immediatamente nuovamente lanciato (come un altro 1) per atterrare a battuta 4ed essere parte del secondo lancio multiplex.)

Lo scambio di siti per l'animazione all'inizio di questo post era [53]15121 .

Validità del modello

Perché uno schema sia semanticamente valido, il numero di palline in una mano deve sempre corrispondere al numero di tiri indicati in quel battito. Questo significa che non ci devono essere palline che atterrano alla battuta con a 0, ci deve essere solo una pallina che atterra alla battuta con qualsiasi altra singola cifra, e non ci devono essere n palline che atterrano a una battuta multiplex, dove n è il numero di cifre in quel lancio multiplex. Lo schema deve anche essere in grado di ripetere senza soluzione di continuità.

Esempi di schemi non validi sono 543(tutte le palline atterrerebbero allo stesso battito), 240( 2atterrerebbero alla 0battuta) o 33[24](nessuna pallina atterra alla battuta multiplex, ma due palline atterrano su entrambe le altre due battute).

La sfida

Prenderai un modello di sitewap che contiene caratteri jolly e ne otterrai uno valido, con quei caratteri jolly compilati.

Prendi come input (tramite stdin, argomento della riga di comando, file o parametro della funzione) una stringa del formato

n s

Dove nè un numero intero che indica il numero di palline da utilizzare ed sè un modello di sitewap ( senza spazi bianchi). Puoi presumere che sia sintatticamente corretto: tutte le parentesi quadre sono abbinate e non nidificate e non ci sono caratteri imprevisti. Tutti i tiri saranno lanci a una cifra ( 0- 9). Tuttavia , alcuni ritmi possono essere indicati come a _, che deve essere compilato con un lancio singolo o multiplex nell'output.

Nota: qualcosa del genere non[_3] farà parte dell'input. O manca l'intero battito o viene dato l'intero battito.

Emette un modello valido, che può essere manipolato con il numero dato di palle e concorda con il modello di input in tutti i battiti specificati. Se non è possibile un modello valido con gli ingressi dati, output !. L'output avverrà anche tramite stdout, su un file o come valore di ritorno della funzione.

Nota: l'output non deve contenere parentesi quadre o zero non necessari in tiri multiplex. Quindi gli output che contengono [3]o [03]non sono accettati, devi 3invece output . L'ordine delle cifre in un lancio multiplex non è rilevante.

Nota: è possibile omettere schemi duplicati in permutazioni cicliche. Ad esempio per l'input 3 __(notare i due caratteri jolly), entrambi 42e 24sono risposte valide (tra gli altri), ma in realtà descrivono lo stesso modello. Puoi produrre entrambi o solo uno di essi, ma dovrai farlo in modo coerente.

Questo è il golf del codice, vince il codice più breve (soggetto ai bonus elencati nella parte inferiore della domanda).

Puoi usare JugglingLab per giocare con i pattern per vedere se sono validi e come sono.

Esempi

Input           Possible Outputs     Comments

3 _             3
                [21]
                [111]

3 4_3           423

4 4_2           4[51]2
                4[42]2
                4[321]2

3 _23_          6231
                4233
                323[31]
                2235
                223[41]
                0237
                023[43]
                [42]231
                [32]23[11]

4 5_3           !                    5 and 3 will both land at the third beat, but
                                     there is only a single throw at that beat. This
                                     cannot be fixed with any throw in the blank.

2 5_4           !                    Any possible throw in the wildcard (including a
                                     0) will make a pattern for at least 3 balls.

3 54_           !                    The only solution that would correspond to a
                                     3-ball pattern is 540, which is not semantically
                                     valid because the 5 and 4 both land at beat 3.
                                     There are valid solutions, but they require at
                                     least 4 balls.

bonus

• Se la tua risposta è in grado di gestire "cifre" fino a 35, indicate da lettere (10 = A, 11 = B, ...), sottrarre 20 caratteri . Puoi decidere se quelle lettere devono essere maiuscole, minuscole o maiuscole. (JugglingLab può gestirli in lettere minuscole se si desidera esaminare alcuni schemi folli.)
• Se la tua risposta produce tutte le soluzioni valide, sottrai 20 caratteri .

Python, 587-20 = 567 caratteri

from itertools import *
E,J,L,R,X=enumerate,''.join,len,range,list
def f(x):
 [u,p]=str.split(x);n=int(u);a=[[[x],x][type(x)==X]for x in eval("["+J(c if c=="["else"-1,"if c=="_"else c+","for c in p)+"]")];l,w=L(a),[i for i,x in E(a)if x==[-1]]
 for j in product([[0]]+X(chain(*[combinations_with_replacement(R(1,10),i+1)for i in R(n+1)])),repeat=L(w)):
  for k,m in zip(w,j):a[k]=m
  b=[0]*l
  for k,x in E(a):
   for y in x:b[(k+y)%l]+=1
  if all(x==L(y)for x,y in zip(b,a))&((sum(map(sum,a))/l)==n):
   u=0;yield J([['['+J(map(str,x))+']',str(x[0])][L(x)==1]for x in a])
 if u:yield"!"