Nessun co-primo vicino

33

Dato un elenco di numeri interi positivi, indica se ogni coppia adiacente di numeri interi in essa condivide un fattore primo. In altre parole, l'output è vero se e solo se non ci sono due numeri interi vicini nell'elenco.

In altri termini: dato un elenco di numeri interi positivi [a 1 a 2 ... a n ] , se si

　　　　　　　mcd (a 1 , a 2 )> 1 && gcd (a 2 , a 3 )> 1 &&… && gcd (a n − 1 , a n )> 1.

L'elenco conterrà sempre almeno due elementi (n ≥ 2).

Tuttavia…

Questa sfida è anche limitato source : i codepoints nella tua risposta (qualunque tabella codici può essere in) deve soddisfare la condizione vostri controlli programma per.

Ad esempio, print 2è un programma valido. Come elenco di punti di codice Unicode è [112 114 105 110 116 32 50] , che soddisfa questa condizione: 112 e 114 condividono un fattore 2 ; e 114 e 105 condividono un fattore 3 , ecc.

Tuttavia, nonmain può verificarsi in un programma valido (scusate!), Poiché i punti di codice Unicode di e , cioè 109 e 97 , sono coprime. (Per fortuna, la tua presentazione non deve essere un programma completo!)ma

Al tuo programma non è consentito contenere il punto codice 0.

Casi test

Truthy:

[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

Falsy:

[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

Questo è code-golf : vince il codice più breve in byte.

code-golf  array-manipulation  restricted-source  decision-problem  primes 
— Lynn
fonte
8
Per chiunque di tentare questa sfida in un normale linguaggio di programmazione, questa è una lista di personaggi che hanno codepoints primi in ASCII: %)+/5;=CGIOSYaegkmq\DEL.
— Cristian Lupascu,
@Lynn I Truthys devono essere coerenti?
— H.Piz,
1
@ H.PWiz No! -
— Lynn,
In realtà intendevo che questo fosse fattibile per alcuni langs normali (non golfistici) e mi sentivo fiducioso quando ho notato che print 2era valido, ma );=aeessere primi è davvero difficile, non ho considerato che ... Mi chiedo se qualcosa come Haskell può competere?
— Lynn,
Questa restrizione è più semplice del contrario di questa domanda , supponiamo che nessuno usi 0x02 byte. Quella domanda ottiene una risposta valida non-golf in Mathematica, Logo, Haskell, Python, Perl, TI-BASIC. Questo ha già un Haskell, penso che Mathematica sia impossibile, ma Logo sembra molto probabile che sia possibile, anche se non ho ancora finito di costruire la soluzione.
— user202729,

Risposte:

15

MATL , 14 byte

!TM1*Zdl2$Xdl-

Ciò genera un vettore di colonna non vuoto di numeri diversi da zero come verità o un vettore contenente almeno una voce zero come falsa.

Spiegazione

!     % 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
— Luis Mendo
fonte
4
Congratulazioni per una risposta che non soddisfano la limitato-source requisito!
— Erik the Outgolfer,
13

Haskell , 103 100 byte

MODIFICARE:

  • -3 byte: utilizzata una d<-fzprotezione per unire e abbreviare le ultime due righe.

fè la funzione principale, che accetta un elenco di numeri interi e restituisce a Bool.

Nota che i primi due ԁ(solo) sono caratteri cirillici (Komi) Unicode e c'è un carattere di tabulazione prima del primo.

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

Provalo online! o testalo su se stesso.

Come funziona

  • fè la funzione principale. Tutto ciò che fa è racchiudere il suo argomento ԁin un elenco singleton (perché il valore ASCII principale di )rende le parentesi molto più scomode da usare rispetto alle parentesi quadre) e chiama zbcon questo e un argomento fittizio (la funzione di Haskell idsembra avere i caratteri giusti per adattarsi Qui).
    • Ottenere lo stesso carattere per adattarsi oltre a entrambi =]è impossibile con ASCII semplice, quindi l'argomento è nominato con il carattere Unicode a 2 byte CYRILLIC SMALL LETTER KOMI DE (ԁ), il valore del punto di codice 3*7*61=U+0501, che si adatta a tutti e [.
      • Poiché il punto di codice non è pari (l'opzione più piccola che è un identificatore legale e utilizza anche tre byte), è necessario utilizzare un carattere di tabulazione anziché uno spazio prima di esso.
      • Un'opzione ASCII sette byte più semplice è quello di rinominare l'argomento: f fz|bf<-fz=zb[bf]fz.
  • zbaccetta due argomenti, un elenco singleton il cui elemento è il vero elenco di numeri su cui si ricorre e un argomento fittizio fznecessario solo per ottenere una zprima della funzione =.
    • Quando l'elenco interno ha almeno due elementi, la funzione zviene chiamata con i primi due (nominati he p) e, se ciò ritorna True, zbricorre sulla coda p:ldell'elenco.
    • Se l'elenco interno ha meno di due elementi, zbrestituisce True. Dal momento che =deve essere seguito dal personaggio z, il modo più semplice per farlo è usare una chiamata della zfunzione che è nota per restituire True.
  • zaccetta due argomenti e calcola ricorsivamente il loro massimo comune divisore usando la sottrazione (ogni altra divisione intera rilevante o funzione gcd non è disponibile), restituendo Truese è maggiore di uno.
    • La ricorsione termina quando il primo argomento è 0, con il secondo argomento è il gcd. Su questa riga viene anche chiamato il secondo argomento z. Il personaggio 1è strano qui, quindi z^0viene utilizzato per ottenere il numero uno.
    • Altrimenti, se il primo argomento fè più piccolo del secondo fz, vengono scambiati e zricorsi.
    • Altrimenti, l'argomento più piccolo viene sottratto dal più grande, quindi viene zricontato (anche scambiando gli argomenti, anche se questo è solo per evitare le parentesi).
— Ørjan Johansen
fonte
2
Ho saputo che ci doveva essere una lingua non-golf che potrebbe tirarlo fuori!
— Lynn,
2
@Lynn Aiuta davvero Haskell in questo tipo di sfida che ha un sottoinsieme sintattico abbastanza espressivo con token a carattere singolo. Il che è circa a metà di una lingua da golf, immagino.
— Ørjan Johansen,
A causa del cirillico, sono davvero 100 byte? Lo script utente Graduazione Code Golf riporta 102 byte UTF-8, ma non so se sia accurato / questo è il modo giusto per contare i byte qui. Non importa quanti byte, è davvero impressionante!
— Mark S.
1
@MarkS. TIO riporta 100 byte (e 98 caratteri). Ho il sospetto che tu sia stato catturato dal carattere di tabulazione, che SE visualizza come 3 spazi (che quindi viene copiato come tale). Penso di aver visto qualcuno usare i pre tag per evitarlo, fammi provare a risolverlo.
— Ørjan Johansen,
@MarkS. Fatto. Anche se sospetto che ciò possa confondere ancora di più tale usercript.
— Ørjan Johansen,
10

05AB1E , 8 byte

Codice

ü‚ÒüÃP≠P

Utilizza la codifica 05AB1E , che ci fornisce il seguente elenco di punti di codice:

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

Provalo online! oppure Verifica il codice sorgente!

Spiegazione

Dato che l'operatore gcd ( ¿) ha un punto in codice primo, ho dovuto cercare altri modi per verificare 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
— Adnan
fonte
Quali punti di codice ha questo nella tabella codici 05AB1E? Puoi aggiungerli nella risposta?
— Mr. Xcoder,
@ Mr.Xcoder aggiunto
— Adnan,
Qualche motivo per Òfinirla f?
— Magic Octopus Urn,
10

Buccia , 8 byte

Per gli input di Truthy restituisce un numero intero positivo, per Falsy restituisce 0

←▼`Ṡt(ż⌋

Provalo online! e testato sui propri punti di codice

Utilizza la tabella codici di Husk

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

Spiegazione

          -- 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
— H.PWiz
fonte
A cosa serve la notazione chiamata che usi nella spiegazione Ṡ? Lo vedo anche nei documenti nella colonna "type" nella pagina dei comandi e non riesco a capirlo, quindi voglio cercarlo in modo che io possa impararlo.
— Jonathan Allan,
@JonathanAllan Questa è la definizione della funzione Ṡnella sintassi di Haskell. Si traduce approssimativamente Ṡ(f,g,x) = f(g(x),x)in più lingue tradizionali.
— Zgarb,
— H.Piz,
Anche se, quando capovolto, diventa`Ṡ g f x = Ṡ f g x = f (g x) x
— H.Piz il
1
@JonathanAllan Se ti unisci alla chat room di Husk , possiamo provare a spiegarlo meglio lì.
— Zgarb,
5

Japt , 8 7 byte

äj d¹¥Z

Provalo online!

Punti codice:

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

Spiegazione

 ä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
— ETHproductions
fonte
5

Gelatina , 11 9 byte

,Pnælð2\P

Salvato 2 byte grazie a @ Jonathan Allan .

Provalo online!

Jelly ha una sua tabella codici e sono i punti di codice di ogni personaggio

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

Questo verifica i numeri non coprimi controllando se lcm(a, b) != a*b. Potrebbe esserci una soluzione più breve poiché ho appena filtrato i caratteri con punti di codice persino.

Spiegazione

,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
— miglia
fonte
Genio! Questo è incredibile: O
— Mr. Xcoder il
,è anche così puoi farlo æln,P¥ð2\per due in meno. Modifica: ho lasciato cadere il trailing P, ne faccio uno in meno: p)
— Jonathan Allan il
Oh sì, scambia anche gli argomenti :)
— Jonathan Allan il
5

TI-BASIC, 38 byte

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

TI-BASIC è tokenizzato in token a uno o due byte, come elencato qui .

Le parti più difficili di questa soluzione sono:

  1. Il token virgola è un numero primo (43), costringendomi a circondarlo con multipli di 43 (in questo caso il token V, che è 86).

  2. Il gcd (token è un numero primo grande (47881), il che significa che non può essere utilizzato affatto.

I token per questo programma vengono a:

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

Spiegazione

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.
— calc84maniac
fonte
3

Pyth , 15 byte

&F.bPiFNP.TtBQQ

Provalo qui o Dai un'occhiata a Test Suite.

Questo è uno sforzo collaborativo tra Erik the Outgolfer e Mr. Xcoder . Restituisce un valore incoerente (elenco non vuoto) per la verità e l'elenco vuoto per la falsità.

ASCII-valori

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

Che condividono i seguenti fattori:

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

Spiegazione

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

Senza il requisito di fonte limitata , questa sarebbe stata una versione da 7 a 5 byte che svolgeva la stessa attività (-2 grazie a FryAmTheEggman ):

-1iVt

Spiegazione

-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)
— Erik the Outgolfer
fonte
Per curiosità, perché hai bisogno della Qs alla fine?
— ETHproductions
@ETHproductions Perché .bha arity variabili e l'utilizzo di input implicito significa che sceglierà il più basso (1) invece di quello previsto (2).
— Erik the Outgolfer
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.