Ceci est un flic et des voleurs si vous n'êtes pas familier avec le format, cliquez sur la balise pour accéder au wiki. Il n'y aura pas de fil de voleurs pour cette question.

Flics

Votre tâche en tant que flics consiste à sélectionner deux séquences dans l' Encyclopédie en ligne des séquences entières et à écrire un programme qui prend le nième élément d'une séquence en entrée et génère le nième élément de la deuxième séquence. Vous répondez ensuite en incluant le code et en omettant les séquences sélectionnées. Les voleurs tenteront de trouver les séquences que vous avez sélectionnées et si l'on parvient à trouver les séquences que vous aviez en tête ou d'autres séquences pour lesquelles votre programme vous devez marquer votre réponse comme Cracked . Si un voleur vous informe d'une fissure que vous croyez non valide, vous pouvez présenter une preuve qu'il ne s'agit pas d'une fissure. Sinon, vous devez le marquer ainsi.

Selon les réponses habituelles qui n'ont pas été fissurées pendant 7 jours, vous pouvez être marqué comme sûr. Un flic peut marquer sa réponse comme sûre en révélant les séquences qu'il avait en tête. Une fois en sécurité, une réponse ne peut plus être craquée.

L'objectif est de minimiser le nombre d'octets de votre programme tout en restant non fissuré.

Exemple

Le code Python suivant traduit le nième élément de A000290 (les nombres carrés) en A000217 (les nombres triangulaires):

lambda x:sum(range(0,int(x**.5+1)))

Stipulations et exigences

• Si vous choisissez une séquence dont il n'est pas prouvé qu'elle est finie, vous devez sortir tous les termes qui pourraient exister, pas seulement ceux répertoriés sur la page OEIS.

• Par exception aux langages de règles précédents sans entiers de précision infinie, il n'est pas nécessaire de sortir ou de saisir des nombres en dehors de leur plage.

• La taille de votre séquence d'entrée ne doit pas être inférieure à la séquence de sortie.

• Votre séquence d'entrée ne doit pas avoir d'éléments de répétition (sinon la tâche est à peu près impossible)

• L'OEIS inclut un index sur leur page (le premier nombre après l'en-tête "OFFSET") par défaut, c'est votre décalage pour n (n est égal à l'index pour le premier élément de la séquence) si vous choisissez un autre index, vous devez l'indiquer dans Ta Réponse.

• Si vous choisissez un décalage différent de celui répertorié sur l'OEIS, vous devez toujours mapper tous les éléments de votre séquence d'entrée à l'élément correspondant dans votre séquence de sortie.

• Si votre programme reçoit une entrée qui n'est pas dans la séquence d'entrée, il peut faire ce qu'il veut (comportement indéfini). Cependant, il est probablement dans votre intérêt qu'il affiche toujours un entier.

• Il est antisportif de rendre intentionnellement votre code difficile à exécuter, que ce soit en le rendant long à exécuter ou via une sélection de langue non libre . Bien que j'applique la seconde, je ne peux pas appliquer objectivement la première. Cependant, je vous implore, pour le plaisir, de ne pas tenter le premier car cela rend le défi spécifiquement plus difficile pour ceux qui ont des ordinateurs plus faibles.

Voleurs

Votre tâche en tant que voleurs est de sélectionner des réponses non fissurées et dangereuses et de trouver les séquences entre lesquelles elles sont mappées. Si vous trouvez une solution qui fonctionne (pas nécessairement la solution prévue par les flics), commentez les séquences sur la réponse appropriée.

Les voleurs ne devraient pas trop se soucier de vérifier que deux séquences particulières sont une solution, on devrait publier une solution si elle correspond à toutes les entrées sur OEIS. Si ce n'est pas la séquence qu'un policier avait en tête, le policier peut offrir une preuve qu'elle est incorrecte ou la marquer comme fêlée s'ils ne peuvent pas en trouver une.

Gelée , 14 octets (fissurée par @Wolfram)

+66%444µ111<µ¡

Essayez-le en ligne!

Cela devrait être assez évident. En fait, pour le bénéfice des utilisateurs non-Jelly, je vais même donner une explication:

Explication

+66%444µ111<µ¡
       µ    µ¡  Run the transformation
+66%444           "add 66, then modulo 444"
        111<    once if 111 is less than the input, zero times otherwise 

La question est, pourquoi fait-il cela?

Fissure

Les séquences en question étaient A201647 et A201647 . Ils sont finis et ne diffèrent que par les 2 derniers éléments:

• 3, 5, 7, 9, 11, 15, 21, 165, 693
• 3, 5, 7, 9, 11, 15, 21, 231, 315

Ainsi, si l'entrée est faible, je la laisse la même et j'adapte simplement une fonction à la transformation des deux dernières.

Gelée , 7 octets (fissurée par @JonathanAllan)

ÆFḅÆdÆẸ

Essayez-le en ligne!

Ce qu'il fait

ÆFḅÆdÆẸ  Main link. Argument: n

ÆF       Factor n into prime-exponent pairs.
   Æd    Compute σ, the number of divisors of n.
  ḅ      Convert each pair from base σ to integer.
     ÆẸ  Yield the integer whose prime signature (infinite sequence of all prime
         exponents, including zeroes, in order) is equal to the result.

Python 3, 256 octets ( fissuré! )

from math import*
def p(i,m):
 r=0;d=floor(log(i))
 for y in range(d):r+=(pow(16,d-y-1)%(8*y+m))/(8*y+m)
 o=-1;y=d
 while r!=o:o=r;r+=pow(16,d-y-1)/(8*y+m);y+=1
 return r
def q(n):r=4*p(n,1)-2*p(n,4)-p(n,5)-p(n,6);return floor((1-(-r%1)if r<0 else r%1)*16)

Essayez-le en ligne!

Désolé si ce code a l'air horrible, je pense que c'est mon premier golf Python. La conversion en Python facilite le codage.

Traitement , 184 octets, SÉCURITAIRE!

int x(int y){int b=TRIANGLES-MITER;for(int i=OVERLAY/BURN;i>#fffffe;b*=(int)pow(y,(MOVE-HAND+0.)/(int)sqrt(red(color(-1<<16))/(int)log(color(0)*color(-1)))),i-=QUAD/DARKEST);return b;}

Une fonction qui prend un int et retourne un int. Tant que le numéro d'entrée est dans intla plage de, le programme devrait fonctionner correctement.

Ce n'est pas lent, juste illisible. Bonne chance!

Je suis surpris que cette communication ait duré aussi longtemps. Eh bien, au moins c'est la première soumission sûre :)

A000578 à A000290

En d'autres termes: les cubes aux carrés.

Explication

En répondant à Aucune chaîne (ou nombre) attachée , j'ai découvert une liste de constantes de traitement qui représentent des entiers. Par exemple, CORNERa une valeur de 0. La liste complète se trouve ici . Pour trouver la valeur d'une constante, vous pouvez simplement la trouver print.

En utilisant cela, j'ai décidé d'échanger certains nombres avec des combinaisons de ces constantes pour l'obscurcir. Voici donc ce que vous obtenez lorsque vous remplacez les constantes par leurs valeurs int respectives.

int x(int y){int b=9-8;for(int i=512/8192;i>#fffffe;b*=(int)pow(y,(13-12+0.)/(int)sqrt(red(color(-1<<16))/(int)log(color(0)*color(-1)))),i-=16/16);return b;}

Même maintenant, le code clair complet n'est pas révélé. Les couleurs restent. Dans Processing, les variables de couleur ont des valeurs int, par exemple white ( #ffffff) is -1, #fffffeis -2, #fffffdis -3, etc. Cela peut être trouvé en printing la couleur. Simplifions donc les couleurs.

int x(int y){int b=9-8;for(int i=512/8192;i>-2;b*=(int)pow(y,(13-12+0.)/(int)sqrt(red(color(-1<<16))/(int)log(-16777216*-1))),i-=16/16);return b;}

Nous sommes à mi-chemin :) Pour comprendre les valeurs, nous devons simplifier les expressions numériques.

int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/(int)sqrt(red(color(-65536))/(int)log(16777216))),i-=1);return b;}

Beaucoup plus clair! Simplifions maintenant le logarithme.

int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/(int)sqrt(red(color(-65536))/(int)16.6...)),i-=1);return b;}


int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/(int)sqrt(red(color(-65536))/16)),i-=1);return b;}

Presque fini! Maintenant, nous devons comprendre cette (int)sqrt(red(color(-65536))/16))bouchée. color(-65536)est rouge, donc rgb(255, 0, 0). Maintenant, la red()fonction renvoie la valeur du composant rouge dans l'argument (qui est une couleur). Alors, combien de rouge y a-t-il en rouge? La réponse est 255. Avec ça on obtient

(int)sqrt(255/16))
(int)sqrt(15)
(int)3.8...
3

La substitution de cela dans le programme se traduit par:

int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/3),i-=1);return b;}

Oui, c'est fait!

int x(int y){                        // y is the cube
  int b=1;                           // variable that holds the final result
  for(int i=0;                       // for-loop that
          i>-2;                      // loops twice
          b*=(int)pow(y,(1.)/3),     // multiply b by the cube root of y
          i-=1);                     // decrement the looping variable
  return b;                          // finally return b
}

Pour résumer, cela renvoie le carré (fait en multipliant deux fois dans la boucle for) de la racine cubique du nombre d'entrée.

Mathematica (ou autre) -  Cracked!

f[x_] := Quotient[ 366403414911466530559405368378193383110620062 - 
    755296348522256690003418238667147075159564695 x + 
    525778437135781349270885523650096958873079916 x^2 - 
    156594194215500250033652167655133583167162556 x^3 + 
    20861131421245483787723229627506507062999392 x^4 - 
    1181515772235154077024719095229309394979146 x^5 + 
    29382627265060088525632055454760915985604 x^6 - 
    308672970015057482559939241399297150364 x^7 + 
    1087516675449597417990589334580403666 x^8 - 
    312989984559486345089577524231879 x^9, 
  265451130886621254401938908479744271974400 ]

Je sais que Mathematica est un logiciel non libre, mais cette fonction est triviale à porter dans la langue préférée dans laquelle vous voulez l'exécuter. Elle calcule littéralement la valeur du polynôme degré 9 donné évalué à l'entier d'entrée, puis prend le quotient entier de cette valeur et le nombre de 42 chiffres sur la dernière ligne. Par exemple, f[100]évalue à -3024847237.