Avec une liste d’entiers positifs, indiquez si chaque paire d’entiers adjacents partage un facteur premier. En d'autres termes, la sortie de vérité si et seulement si aucun deux entiers voisins de la liste ne sont co-premiers.

En d’autres termes encore: à partir d’une liste d’entiers positifs [a ₁ a ₂ … a _n ] , indiquer si

　　　　　　　gcd (a ₁ , a ₂ )> 1 && gcd (a ₂ , a ₃ )> 1 &&… && gcd (a _{n − 1} , a _n )> 1.

La liste contiendra toujours au moins deux éléments (n ≥ 2).

Toutefois…

Ce défi est également à source restreinte : les points de code dans votre réponse (quelle que soit la page de code dans laquelle il se trouve) doivent satisfaire à la condition recherchée par votre programme.

Par exemple, print 2est un programme valide. En tant que liste de points de code Unicode, il s'agit de [112 114 105 110 116 32 50] , qui remplit cette condition: 112 et 114 partagent un facteur 2 ; et 114 et 105 partagent un facteur de 3 , etc.

Cependant, nemain peut pas se produire dans un programme valide (désolé!), Car les points de code Unicode de met a, à savoir 109 et 97 , sont coprimes. (Heureusement, votre soumission ne doit pas être un programme complet!)

Votre programme n'est pas autorisé à contenir le code 0.

Cas de test

Vérité

[6 21] -> 1
[502 230 524 618 996] -> 1
[314 112 938 792 309] -> 1
[666 642 658 642 849 675 910 328 320] -> 1
[922 614 530 660 438 854 861 357 477] -> 1

Fausseté:

[6 7] -> 0
[629 474 502 133 138] -> 0
[420 679 719 475 624] -> 0
[515 850 726 324 764 555 752 888 467] -> 0
[946 423 427 507 899 812 786 576 844] -> 0

C'est code-golf : le code le plus court en octets gagne.

MATL , 14 octets

!TM1*Zdl2$Xdl-

Ceci produit un vecteur colonne non vide de nombres non nuls comme vérité, ou un vecteur contenant au moins une entrée zéro comme faux.

• Essayez-le en ligne!

• Vérifier tous les cas de test . Le code de pied de page contient une ifbranche permettant de tester vérité / fausseté.

• Puisque MATL utilise ASCII, le code source est codé comme suit:

  [33 84 77 49 42 90 100 108 50 36 88 100 108 45]
  

  qui répond à l'exigence .

Explication

!     % Implicit input. Transpose
TM    % Push input to latest function again
1*    % Multiply by 1 (does nothing, but matches factors)
Zd    % Compute gcd with broadcast: matrix of gcd of all pairs
l     % Push 1
2$    % The next function will use 2 inputs
Xd    % Extract diagonal 1 (i.e. that below the main diagonal) from the matrix
l-    % Subtract 1 from each entry. Implicitly display

Haskell , 103 à 100 octets

MODIFIER:

• -3 octets: Utilisé a d<-fz garde pour fusionner et raccourcir les deux dernières lignes.

fest la fonction principale, qui prend une liste d’entiers et retourne un Bool.

Notez que les deux premiers caractères ԁ(uniquement) sont des caractères cyrilliques (Komi) Unicode et qu’il y a un caractère de tabulation avant le premier.

f	ԁ=zb[ԁ]id
zb[h:p:l]fz=z h p&&zb[p:l]fz
zb l fz=z 0 2
z 0z=z>z^0
z f fz|f<fz=z fz f|d<-fz=z d$f-d

Essayez-le en ligne! ou le tester sur lui-même.

Comment ça marche

• fest la fonction principale. Tout ce qu’il fait est d’envelopper son argument ԁdans une liste de singleton (parce que la valeur ASCII primordiale de )rend les parenthèses beaucoup plus difficiles à utiliser que les crochets) et d’appeler zbavec cela et un argument factice (la fonction Haskell ida justement les bons caractères ici).
  • Il =]est impossible d' obtenir le même caractère en plus des deux avec l'ASCII ordinaire. Par conséquent, l'argument est nommé avec le caractère Unicode à 2 octets CYRILLIC SMALL LETTER KOMI DE (ԁ), valeur du point de code 3*7*61=U+0501, qui convient à tous ceux et à [.
    • Étant donné que le point de code n'est pas pair (la plus petite option est un identifiant légal et utilise même trois octets), il est nécessaire d'utiliser un caractère de tabulation au lieu d'un espace avant.
    • Une option ASCII plus de sept octets est de renommer l'argument: f fz|bf<-fz=zb[bf]fz.
• zbprend deux arguments, une liste singleton dont l’élément est la liste réelle des nombres sur lesquels on fait la récurrence, et un argument factice fzn’est nécessaire que pour obtenir un zavant la fonction de =s.
  • Quand la liste interne a au moins deux éléments, la fonction zest appelée avec les deux premiers (nommés het p), et si cela retourne True,zb récurrente à la fin p:lde la liste.
  • Si la liste interne contient moins de deux éléments, zbretourne True. Comme il =doit être suivi par le caractère z, le moyen le plus simple consiste à utiliser un appel de la zfonction connue pour son retour True.
• z prend deux arguments et calcule récursivement son plus grand diviseur commun en utilisant la soustraction (toute autre division pertinente ou fonction gcd n’est pas disponible), ce qui retourne True si elle est supérieure à un.
  • La récursivité se termine lorsque le premier argument est 0, le second argument étant le gcd. Sur cette ligne, le deuxième argument est également nommé z. Le caractère 1est maladroit ici, donc z^0est utilisé pour obtenir le numéro un.
  • Sinon, si le premier argument fest plus petit que le second fz, ils sont échangés et zrécursifs.
  • Sinon, l'argument le plus petit est soustrait du plus gros, puis se zrépète (en échangeant également les arguments, bien que ce soit juste pour éviter les parenthèses.)

05AB1E , 8 octets

Code

ü‚ÒüÃP≠P

Utilise le codage 05AB1E , ce qui nous donne la liste suivante de points de code:

hex: [0xFC, 0x82, 0xD2, 0xFC, 0xC3, 0x50, 0x16, 0x50]
dec: [252,  130,  210,  252,  195,  80,   22,   80]

Essayez-le en ligne! ou Vérifiez le code source!

Explication

Étant donné que l'opérateur gcd ( ¿) a un point de code principal, je devais rechercher d'autres moyens de vérifier la coprimalité:

ü‚          # Get an array of adjacent pairs of the input
  Ò         # Factorize both elements of each pair in the array
   üà       # For each pair, get the intersection of both prime factorization lists
     P      # Product of each intersection (this leaves 1 when there is no intersection)
      ≠     # Check for each element whether it does not equal 1
       P    # Product of the booleans

Coque , 8 octets

Pour les entrées Truthy, il renvoie un entier positif, pour Falsy, il renvoie 0

←▼`Ṡt(ż⌋

Essayez-le en ligne! et testé sur ses propres points de code

Utilise la page de code de Husk

Source -- [ ←  , ▼  , `  , Ṡ  , t  , (  , ż  , ⌋  ]
Hex    -- [0x06,0xbd,0x60,0xd0,0x74,0x28,0xeb,0x8d]
Dec    -- [6   ,189 ,96  ,208 ,116 ,40  ,235 ,141]

Explication

          -- implicit input, e.g                                  [63,36,18,3]
  `       -- flip the args of the next function
   Ṡ      -- some combinator (Ṡ f g x = f (g x) x)
    t     -- tail                                                 [36,18,3]
      ż   -- zipWith (note, keeps trailing elems of longer list)  [(63,36),(36,18),(18,3),(3)]
       ⌋  -- gcd                                                  [9,9,3,3]
     (    -- used just to match restricted source criteria
 ▼        -- minimum of the list                                    3
←         -- minus 1                                                2

Japt , 8 7 octets

äj d¹¥Z

Testez-le en ligne!

Points de code:

Char    ä   j       d   ¹   ¥   Z
Hex    e4  6a  20  64  b9  a5  5a
Dec   228 106  32 100 185 165  90

Explication

 äj d¹ ¥ Z
Uäj d) ==Z
             Implicit: U = input array, Z = 0
Uä           For each pair of items in the array:
  j            Return whether the two items are coprime.
    d)       Return true if any items are truthy, false otherwise.
       ==Z   Return whether this is equal to 0 (false -> true, true -> false).
             Implicit: output result of last expression

Gelée , 11 à 9 octets

,Pnælð2\P

Enregistré 2 octets grâce à @ Jonathan Allan .

Essayez-le en ligne!

La gelée a sa propre page de code et les points de code de chaque caractère sont

Chr Hex Dec
,   2c   44
P   50   80
n   6e  110
æ   16   22
l   6c  108
ð   18   24
2   32   50
\   5c   92
P   50   80

Ceci teste les numéros non coprimes en vérifiant si lcm(a, b) != a*b. Il pourrait y avoir une solution plus courte car je viens de filtrer les caractères ayant même des points de code.

Explication

,Pnælð2\P  Input: array A
      2\   For each overlapping sublist of size 2
     ð       Reduce it using this dyad
,              Pair
 P             Product
  n            Not equals, 1 if true else 0
   æl          LCM
        P  Product

TI-BASIC, 38 octets

Input L1:ΔList(cumSum(L1:augment(Ans+V,V+{0:2>sum(AnsL1=lcm(Ans+V,V+L1

TI-BASIC est segmenté en jetons d'un ou deux octets, comme indiqué ici .

Les parties les plus délicates de cette solution étaient:

1. Le jeton de virgule est un nombre premier (43), ce qui m'oblige à l'entourer de multiples de 43 (dans ce cas, le jeton V, qui est 86).

2. Le gcd (le jeton est un grand nombre premier (47881), ce qui signifie qu'il ne peut pas être utilisé du tout.

Les jetons pour ce programme sortent à:

token     hex     dec
Input     0xDC    220
L1        0x5D00  23808
:         0x3E    62
ΔList(    0xBB2C  47916
cumSum(   0xBB29  47913
L1        0x5D00  23808
:         0x3E    62
augment(  0x14    20
Ans       0x72    114
+         0x70    112
V         0x56    86
,         0x2B    43
V         0x56    86
+         0x70    112
{         0x08    8
0         0x30    48
:         0x3E    62
2         0x32    50
>         0x6C    106
sum(      0xB6    182
Ans       0x72    114
L1        0x5D00  23808
=         0x6A    106
lcm(      0xBB08  47880
Ans       0x72    114
+         0x70    112
V         0x56    86
,         0x2B    43
V         0x56    86
+         0x70    112
L1        0x5D00  23808

Explication

Input L1:                   Prompt the user to input L1.

ΔList(cumSum(L1:            Take the differences of the prefix sum of L1,
                            which in effect removes the first element (result in Ans).

augment(Ans+V,V+{0:         Append a 0 to the end of Ans.
                            V defaults to 0, so adding it is a no-op.
                            Ans now holds L1 shifted to the left by one element,
                            with a 0 shifted in.

      AnsL1=lcm(Ans+V,V+L1  Take the least common multiple of each corresponding element
                            of Ans and L1, and check if each is equal to their product.
                            This returns a list of booleans, each 1 corresponding to
                            a co-prime pair. The last element (having been paired with 0)
                            will always be 1.

2>sum(                      Returns 1 if there is at most one 1 in the list, else 0.
                            Since the last element is always 1, this means
                            we return 1 only if there are no co-prime pairs.

Pyth , 15 octets

&F.bPiFNP.TtBQQ

Essayez-le ici ou consultez Test Suite.

C’est un effort de collaboration entre Erik the Outgolfer et M. Xcoder . Retourne une valeur incohérente (liste non vide) pour la vérité et la liste vide pour la fausseté.

Valeurs ASCII

[38, 70, 46, 98, 80, 105, 70, 78, 80, 46, 84, 116, 66, 81, 81]

Quelle part des facteurs suivants:

[2, 2, 2, 2, 5, 35, 2, 2, 2, 2, 4, 2, 3, 81]

Explication

&F.bPiFNP.TtBQQ
           tBQ   Return [Q, Q[1:]] (Q = eval first line of input)
         .T      Transpose ^ without cropping absences
        P        Remove last element of ^
  .b          Q  Map in parallel on ^ (N) and Q (Y, ignored)
     iFN           GCD of N
    P              Prime factors of ^ (P(1) = [])
&F               Left fold (reduce) the result of the map with Logical AND (short-circuiting)

Sans l' exigence de source restreinte , il s'agirait d'une version à 7 octets 5 accomplissant la même tâche (-2 grâce à FryAmTheEggman ):

-1iVt

Explication

-1iVtQQ  Implicit QQ at the end
    tQ   Return Q[1:]
  iV  Q  Vectorized GCD on ^ and Q
-1       Remove every element of ^ from [1] (implicit singleton)