Nous définissons un tableau binaire comme un tableau satisfaisant les propriétés suivantes:
- c'est non vide
- la première valeur est un
1
- la dernière valeur est un
1
- toutes les autres valeurs sont soit
0
ou1
Par exemple, le tableau [ 1, 1, 0, 1 ]
est un tableau de binaires valide .
La tâche
Étant donné un tableau non vide A d'entiers non négatifs et un entier positif N , votre travail consiste à trouver un tableau binaire B de longueur N qui permet de générer A en sommant un nombre illimité de copies de B , décalé d'un nombre illimité de postes.
Exemple
A = [ 1, 1, 2, 4, 1, 2, 2, 1, 0, 1, 0, 1, 1, 0, 1 ]
N = 4
Pour cette entrée, le binarray B = [ 1, 1, 0, 1 ]
serait une réponse valide car nous pouvons faire:
[ 1, 1, 0, 1 ]
+ [ 1, 1, 0, 1 ]
+ [ 1, 1, 0, 1 ]
+ [ 1, 1, 0, 1 ]
+ [ 1, 1, 0, 1 ]
+ [ 1, 1, 0, 1 ]
-----------------------------------------------
= [ 1, 1, 2, 4, 1, 2, 2, 1, 0, 1, 0, 1, 1, 0, 1 ]
Règles
- L'entrée peut être prise dans n'importe quel format raisonnable.
- La sortie peut être un tableau natif (par exemple
[1, 1, 0, 1]
) ou une chaîne binaire avec ou sans séparateur (par exemple"1,1,0,1"
ou"1101"
) - Vous n'êtes tenu d'imprimer ou de retourner qu'un seul binarray valide . Vous pouvez également choisir d'imprimer ou de retourner tous lorsqu'il existe plusieurs solutions.
- Vous n'êtes pas tenu de prendre en charge les entrées qui ne conduisent à aucune solution.
- La somme peut inclure des zéros implicites qui ne se chevauchent pas avec une copie de B . Le deuxième zéro de la somme ci-dessus est un tel zéro implicite.
- Vous pouvez supposer que la taille maximale de A est 100 et la taille maximale de B est 30.
- Il s'agit de code-golf, donc la réponse la plus courte en octets l'emporte. Les failles standard sont interdites.
Cas de test
Input : N = 1 / A = [ 1, 2, 3, 4, 5 ]
Output: [ 1 ]
Input : N = 2 / A = [ 1, 2, 100, 99 ]
Output: [ 1, 1 ]
Input : N = 3 / A = [ 1, 1, 1 ]
Output: [ 1, 1, 1 ]
Input : N = 3 / A = [ 1, 1, 3, 2, 2 ]
Output: [ 1, 1, 1 ]
Input : N = 3 / A = [ 1, 0, 2, 1, 1, 1, 0, 0, 1, 0, 1 ]
Output: [ 1, 0, 1 ]
Input : N = 4 / A = [ 1, 2, 2, 2, 1 ]
Output: [ 1, 1, 1, 1 ]
Input : N = 4 / A = [ 1, 1, 2, 4, 1, 2, 2, 1, 0, 1, 0, 1, 1, 0, 1 ]
Output: [ 1, 1, 0, 1 ]
Input : N = 4 / A = [ 1, 1, 0, 2, 1, 0, 1 ]
Output: [ 1, 0, 0, 1 ] or [ 1, 1, 0, 1 ]
Input : N = 5 / A = [ 1, 3, 6, 9, 8, 6, 3, 4 ]
Output: [ 1, 1, 1, 0, 1 ]
Input : N = 8 / A = [ 2, 1, 0, 2, 3, 3, 1, 2, 1 ]
Output: [ 1, 0, 0, 1, 1, 1, 0, 1 ]
Input : N = 10 / A = [ 1, 2, 1, 2, 2, 1, 3, 3, 3, 2, 3, 0, 2, 1, 1, 0, 1 ]
Output: [ 1, 1, 0, 1, 0, 1, 1, 1, 0, 1 ]
Input : N = 13 / A = [ 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1 ]
Output: [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ]
Input : N = 5 / A = [ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ]
Output: [ 1, 1, 1, 1, 1 ]
Input : N = 6 / A = [ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ]
Output: [ 1, 0, 0, 0, 0, 1 ]
Input : N = 7 / A = [ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ]
Output: [ 1, 1, 0, 0, 0, 1, 1 ]
Input : N = 9 / A = [ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ]
Output: [ 1, 0, 1, 0, 1, 0, 1, 0, 1 ]
N=4, A = [ 1, 1, 2, 4, 1, 2, 2, 2, 1, 2, 2, 1, 2, 0, 1 ]
, vous obtenez 30459 qui est divisible par 11 et 13 mais un seul [ 1, 1, 0, 1 ]
et [ 1, 0, 1, 1 ]
est une réponse valide.
N
cela qui devrait raisonnablement être prise en charge?