Una nota canzone della rock band irlandese U2 inizia con il cantante Bono che dice "1, 2, 3, 14" in spagnolo (" uno, dos, tres, catorce ").

Esistono varie teorie sul significato di questi numeri. Apparentemente la spiegazione ufficiale è " abbiamo bevuto troppo quella notte ". Ma c'è un'ipotesi più interessante: Bono si riferisce a una sequenza intera di OEIS, come ad esempio

A107083 :

Numeri interi kche 10^k + 31sono primi.
1, 2, 3, 14, 18, 44, 54, ...

In un'intervista, quando gli è stata posta l'inevitabile domanda "perché 14", Bono ha ammesso di essere un po 'stanco di quel numero. Il giornalista suggerì invece "15", e in quel concerto di quella sera i testi furono effettivamente cambiati in "1, 2, 3, 15". (La storia può essere letta qui , in spagnolo). Molto probabilmente il giornalista si è ispirato

A221860 :

Indici ktale che prime(k) - kè un potere di 2, dove prime(k)è il k-th primo.
1, 2, 3, 15, 39, 2119, 4189897, ...

La sfida

Scrivi due programmi nella stessa lingua. Il primo dovrebbe prendere un input ne produrre il -thn termine di A107083 , o i primi ntermini. Allo stesso modo, il secondo dovrebbe produrre l' undicesimon termine di A221860 , o i primi ntermini.

Il punteggio è la somma delle lunghezze dei due programmi, in byte, più il quadrato della distanza di Levenshtein tra le rappresentazioni di byte dei due programmi.

Se viene utilizzata una codifica dei caratteri in modo tale che ogni carattere corrisponda a un byte, questo script può essere utilizzato per misurare la distanza di Levenshtein.

Ad esempio, se i due programmi sono abcdefghe bcdEEfg, il punteggio è 8 + 7 + 4^2 = 31.

Il punteggio più basso vince.

Regole Adizionali

• L'output può essere 1basato o 0basato, indipendentemente per ciascuna sequenza (quindi è consentito se uno dei programmi è 1basato e l'altro è 0basato).

• Ogni programma può, in modo coerente ma indipendente dall'altro, produrre il ntermine o il primo ntermine.

• Sono consentiti programmi o funzioni, indipendentemente per ciascuna sequenza.

• I mezzi e il formato di input e output sono flessibili come al solito . Sono vietate le scappatoie standard .

Gelatina , 16 + 16 + 1² = 33

A107083

⁵*+31ÆḍÆNB>/
1Ç#

Provalo online!

A221860

⁵*+31ÆạÆNB>/
1Ç#

Provalo online!

Come funziona

1Ç#           Main link. Argument: n

1             Set the return value to 1.
 Ç#           Call the helper link with arguments k, k + 1, k + 2, ... until n of
              them return a truthy value. Return the array of n matches.


⁵*+31ÆḍÆNB>/  Helper link. Argument: k

⁵*            Yield 10**k.
  +31         Yield 10**k + 31.
     Æḍ       Count the proper divisors of 10**k + 31.
              This yields c = 1 if 10**k + 31 is prime, an integer c > 1 otherwise.
       ÆN     Yield the c-th prime.
              This yields q = 2 if 10**k + 31 is prime, a prime q > 2 otherwise.
         B    Binary; yield the array of q's digits in base 2.
          >/  Reduce by "greater than".
              This yields 1 if and only if the binary digits match the regex /10*/,
              i.e., iff q is a power of 2, i.e., iff 10**k + 31 is prime.


⁵*+31ÆạÆNB>/  Helper link. Argument: k

     Æ        Unrecognized token.
              The token, as well as all links to its left, are ignored.
       ÆN     Yield p, the k-th prime.
      ạ       Take the absolute difference of k and p, i.e., p - k.
         B    Binary; yield the array of (p - k)'s digits in base 2.
          >/  Reduce by "greater than".
              This yields 1 if and only if the binary digits match the regex /10*/,
              i.e., iff p - k is a power of 2.

Pyth , 9 + 11 + 9² = 101 byte

1, 2, 3, 14

.fP_+31^T

Provalo online!

1, 2, 3, 15

.fsIl-e.fP_

Provalo online!

Gelatina , 12 + 12 + 8² = 88 byte

1, 2, 3, 14

ÆN_µæḟ2=
1Ç#

Provalo online!

1, 2, 3, 15

10*+31ÆP
1Ç#

Provalo online!

Gelatina , 11B + 10B + 7B² = 70

1, 2, 3, 14

⁵*+31ÆP
1Ç#

Provalo online!

1, 2, 3, 15

ạÆNBSỊ
1Ç#

Provalo online!

MATL , 17 + 17 + 7² = 83

1, 2, 3, 14, ... (17 byte)

0G:"`Q11qy^31+Zp~

Provalo online!

1, 2, 3, 15, ... (17 byte)

0G:"`QtYqy-Bzq~p~

Provalo online!

Entrambi impiegano lo stesso schema di 0G:"`Qavere un contatore in esecuzione e di ritorno quando una condizione è stata soddisfatta nvolte. Il programma attuale è quindi abbastanza semplice. La 15variante ha un filler ( ~p~) per minimizzare la distanza di Levenshtein, mentre il 14programma impiega 11qypiuttosto che t10wabbinare meglio l'altro programma.

Parte condivisa:

0      % Push counter (initially zero)
 G:"   % Loop `n` times
    `  % Do .... while true
     Q % Increment counter

Programma principale:

11q         % Push 10
   y        % Duplicate counter
    ^       % Power
     31+    % Add 31
        Zp  % isprime
          ~ % If not, implicitly continue to next iteration. 
            % Else, implicit display of counter.

Programma inferiore:

tYq         % Nth prime based on counter
   y-       % Duplicate counter, subtract from nth prime.
     Bzq    % Number of ones in binary presentation, minus one (only zero for powers of two).
        ~p~ % Filler, effectively a NOP.
            % If not zero, implicitly continue to next iteration
            % Else, implicitl display of counter.

05AB1E (legacy) , 10 + 11 + 6 ² = 84 69 57 byte

1, 2, 3, 14, ... (A107083)

ε>а32<+p

Provalo online.

1, 2, 3, 15, ... (A221860)

ε>Ð<ØαD<&_

Provalo online.

$n$

½counter_variableµcounter_variable$a$

Spiegazione:

Î            # Push 0 and the input
 µ           # While the counter_variable is not equal to the input yet:
  >          #  Increase the top by 1
   Ð         #  Triplicate it (which is our `k`)
    °32<+    #  Take 10 to the power `k`, and add 31
         p   #  Check if this is a prime
             #  (implicit: if it is a prime, increase the counter_variable by 1)
             # (implicitly output the top of the stack after the while-loop)

Î            # Push 0 and the input
 µ           # While the counter_variable is not equal to the input yet:
  >          #  Increase the top by 1
   Ð         #  Triplicate it (which is out `k`)
    <Ø       #  Get the 0-indexed k'th prime
      α      #  Get the absolute difference of this prime with the copied `k`
       D<&   #  Calculate `k` Bitwise-AND `k-1`
          _  #  And check if this is 0 (which means it's a power of 2)
             #  (implicit: if it is 0, increase the counter_variable by 1)
             # (implicitly output the top of the stack after the while-loop)