Una conocida canción de la banda de rock irlandesa U2 comienza con el cantante Bono diciendo "1, 2, 3, 14" en español (" uno, dos, tres, catorce ").

Hay varias teorías sobre el significado de esos números. Al parecer, la explicación oficial es " bebimos demasiado esa noche ". Pero hay una hipótesis más interesante: Bono se refiere a una secuencia entera de OEIS, como

A107083 :

Enteros ktales que 10^k + 31es primo.
1, 2, 3, 14, 18, 44, 54, ...

En una entrevista, cuando se le hizo la inevitable pregunta "por qué 14", Bono admitió que estaba un poco cansado de ese número. El periodista sugirió "15" en su lugar, y en el concierto de esa noche la letra se cambió a "1, 2, 3, 15". (La historia se puede leer aquí , en español). Muy probablemente el periodista se inspiró en

A221860 :

Índices ktales que prime(k) - kes un poder de 2, donde prime(k)está la kenésima prima
1, 2, 3, 15, 39,2119 , 4189897, ...

El reto

Escribe dos programas en el mismo idioma. El primero debe tomar una entrada ny salida ndel enésimo término de A107083 , o los primeros ntérminos. Del mismo modo, el segundo debería generar el enésimon término de A221860 , o los primeros ntérminos.

La puntuación es la suma de las longitudes de los dos programas, en bytes, más el cuadrado de la distancia de Levenshtein entre las representaciones de bytes de los dos programas.

Si se usa una codificación de caracteres de modo que cada carácter corresponda a un byte, este script se puede usar para medir la distancia de Levenshtein.

Por ejemplo, si los dos programas son abcdefghybcdEEfg , la puntuación es 8 + 7 + 4^2 = 31.

La puntuación más baja gana.

Reglas adicionales

• La salida puede basarse 1o basarse 0, independientemente para cada secuencia (por lo que se permite si uno de los programas está 1basado y el otro está 0basado).

• Cada programa puede, de manera consistente pero independiente del otro, generar el nenésimo término o los primeros ntérminos.

• Se permiten programas o funciones, independientemente para cada secuencia.

• Los medios y formatos de entrada y salida son flexibles como de costumbre . Las lagunas estándar están prohibidas .

Jalea , 16 + 16 + 1² = 33

A107083

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

Pruébalo en línea!

A221860

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

Pruébalo en línea!

Cómo funciona

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 bytes

1, 2, 3, 14

.fP_+31^T

Pruébalo en línea!

1, 2, 3, 15

.fsIl-e.fP_

Pruébalo en línea!

Jalea , 12 + 12 + 8² = 88 bytes

1, 2, 3, 14

ÆN_µæḟ2=
1Ç#

Pruébalo en línea!

1, 2, 3, 15

10*+31ÆP
1Ç#

Pruébalo en línea!

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

1, 2, 3, 14

⁵*+31ÆP
1Ç#

Pruébalo en línea!

1, 2, 3, 15

ạÆNBSỊ
1Ç#

Pruébalo en línea!

MATL , 17 + 17 + 7² = 83

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

0G:"`Q11qy^31+Zp~

Pruébalo en línea!

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

0G:"`QtYqy-Bzq~p~

Pruébalo en línea!

Ambos emplean el esquema similar de 0G:"`Qtener un contador funcionando y regresando cuando una condición se ha cumplido nveces. El programa actual es bastante sencillo. La 15variante tiene algo de relleno ( ~p~) para minimizar la distancia de Levenshtein, mientras que el 14programa emplea un programa en 11qylugar de t10wcoincidir mejor con el otro.

Parte compartida:

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

Programa superior:

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

Programa inferior:

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 (heredado) , 10 + 11 + 6 ² = 84 69 57 bytes

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

ε>а32<+p

Pruébalo en línea.

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

ε>Ð<ØαD<&_

Pruébalo en línea.

Ambos generan el 1 basado $n$th valor.

Utiliza la versión heredada de 05AB1E, ya que lo hace ½( aumenta counter_variableen 1 si la parte superior de la pila es verdadera ) implícitamente después de cada iteración de µ-loops ( mientras counter_variableque no es igual a$a$aún, hacer ... ).

Explicación:

Î            # 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)