Uma música bem conhecida da banda de rock irlandesa U2 começa com o cantor Bono dizendo "1, 2, 3, 14" em espanhol (" uno, dos, tres, catorce ").

Existem várias teorias sobre o significado desses números. Aparentemente, a explicação oficial é " bebemos demais naquela noite ". Mas há uma hipótese mais interessante: Bono está se referindo a uma sequência inteira do OEIS, como

A107083 :

Inteiros, ktais como 10^k + 31primos.
1, 2, 3, 14, 18, 44, 54, ...

Em uma entrevista, quando a pergunta inevitável "por que 14", Bono admitiu que estava um pouco cansado desse número. O jornalista sugeriu "15" e, no concerto daquela noite, as letras foram de fato alteradas para "1, 2, 3, 15". (A história pode ser lida aqui , em espanhol). Muito provavelmente o jornalista se inspirou em

A221860 :

Índices kque prime(k) - ksão uma potência de 2, onde prime(k)é o k-ésimo primo.
1, 2, 3, 15, 39, 2119, 4189897, ...

O desafio

Escreva dois programas no mesmo idioma. O primeiro deve receber ne gerar o ntermo- A107083 , ou o primeiro ntermo. Da mesma forma, o segundo deve gerar o n-ésimo termo de A221860 ou os primeiros ntermos.

A pontuação é a soma dos comprimentos dos dois programas, em bytes, mais o quadrado da distância de Levenshtein entre as representações de bytes dos dois programas.

Se uma codificação de caracteres for usada de modo que cada caractere corresponda a um byte, esse script poderá ser usado para medir a distância de Levenshtein.

Por exemplo, se os dois programas forem abcdefghe bcdEEfg, a pontuação será 8 + 7 + 4^2 = 31.

Menor pontuação ganha.

Regras adicionais

• A saída pode ser 1baseada ou 0baseada, independentemente para cada sequência (portanto, é permitido se um dos programas for 1baseado e o outro for 0baseado).

• Cada programa pode, de maneira consistente mas independente do outro, ngerar o -ésimo termo ou os primeiros ntermos.

• Programas ou funções são permitidos, independentemente para cada sequência.

• Os meios e o formato de entrada e saída são flexíveis, como de costume . As brechas padrão são proibidas .

Gelatina , 16 + 16 + 1² = 33

A107083

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

Experimente online!

A221860

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

Experimente online!

Como 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.

Pitão , 9 + 11 + 9² = 101 bytes

1, 2, 3, 14

.fP_+31^T

Experimente online!

1, 2, 3, 15

.fsIl-e.fP_

Experimente online!

Gelatina , 12 + 12 + 8² = 88 bytes

1, 2, 3, 14

ÆN_µæḟ2=
1Ç#

Experimente online!

1, 2, 3, 15

10*+31ÆP
1Ç#

Experimente online!

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

1, 2, 3, 14

⁵*+31ÆP
1Ç#

Experimente online!

1, 2, 3, 15

ạÆNBSỊ
1Ç#

Experimente online!

MATL , 17 + 17 + 7² = 83

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

0G:"`Q11qy^31+Zp~

Experimente online!

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

0G:"`QtYqy-Bzq~p~

Experimente online!

Ambos empregam o esquema semelhante de 0G:"`Qter um contador funcionando e retornando quando uma condição é atendida várias nvezes. O programa atual é bastante direto. A 15variante possui algum preenchimento ( ~p~) para minimizar a distância de Levenshtein, enquanto o 14programa emprega um11qy vez de t10wcorresponder melhor ao outro programa.

Parte compartilhada:

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

Programa principal:

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

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

ε>а32<+p

Experimente online.

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

ε>Ð<ØαD<&_

Experimente online.

Ambos emitem o 1-based $n$th valor.

Usa a versão legada de 05AB1E, pois aumenta½ ( 1 em aumento counter_variablese a parte superior da pilha for verdadeira ) implicitamente após cada iteração de µ-loops ( enquanto counter_variablenão for igual a$a$ainda, faça ... ).

Explicação:

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