Je parle de cette question , jetez-y un œil si vous êtes un peu confus.

Tâche principale

Votre tâche consiste à produire des entiers concaténés, dans l'ordre décroissant, mais en augmentant l'entier maximal à chaque fois que vous frappez 1 (pour cette question, 1 sera considéré comme un nombre premier) . Bien que cela ne semble pas différent de la première question, voici la partie délicate: tous les nombres générés ne peuvent être que des nombres premiers . Celles-ci seront regroupées en une seule chaîne sans espaces ni sauts de ligne. Votre entrée sera également un nombre premier .

Exemple:

1
21
321
5321
75321
1175321
Valid output:
1213215321753211175321

Contribution

Votre code ne peut prendre qu'une seule entrée: le plus haut nombre premier à imprimer. Cette entrée peut provenir de n'importe où (graphique, STDIN). Vous êtes assuré que l'entrée est un nombre premier.

Production

Vous devrez sortir le nombre résultant. Vous pouvez obtenir ce nombre en continuant à décompter, ne comptez le nombre que si c'est un nombre premier, puis connectez tous les résultats ensemble à un seul nombre. Le dernier numéro "ligne" (par exemple 7, 5, 3, 2, 1) doit être imprimé entièrement. La sortie peut être n'importe quoi (nombres, chaînes, graphiques), tant qu'elle est lisible. Le même modèle Regex pour vérifier vos cas de test s'applique:

^(\D*(\d)+\D*|)$

Si votre sortie ne correspond pas à ce modèle, votre code n'est pas valide.

Règles

• L'entrée est assurée d'être principale, n'incluez pas la gestion des erreurs, sauf si vous le souhaitez / devez.
• La sortie peut n'être qu'un numéro entièrement connecté, donc pas divisée par quoi que ce soit, pas même des sauts de ligne.
• Votre algorithme ne doit pas vérifier la première instance d' Napparition (par exemple, le 17in 1175321), mais plutôt la première instance de Ncomme le nombre réel.
• Votre contribution est assurée d'être positive, n'ajoutez pas de manipulation à moins que vous ne le souhaitiez / en ayez besoin.

Cas de test

Input: -2, 0
Output: Any, or none (number isn't positive)

Input: 9
Output: Any, or none (number isn't prime)

Input: 1
Output: 1

Input: 7
Output: 121321532175321

Input: 23
Output: 1213215321753211175321131175321171311753211917131175321231917131175321

Gagnant

C'est du code-golf , donc l'auteur du code avec le moins de longueur en octets gagne!

Gelée , 9 octets

ÆR1;;\UFV

Essayez-le en ligne!

Comment ça fonctionne

ÆR1;;\UFV  Main link. Argument: n

ÆR         Prime range; yield all primes up to n.
  1;       Prepend the "prime" 1.
    ;\     Cumulative concatenation; yield all prefixes of the prime range.
      U    Upend; reverse each prefix.
       F   Flatten the resulting 2D array.
        V  Eval. This casts the integer array to string first, thus concatenating
           the integers.

Traitement, 161 octets

int p(int n){for(int k=1;++k<=sqrt(n);)if(n%k<1)return 0;return 1;}void t(int n){for(int i=1,j;i<=n;i++){if(p(i)<1)continue;for(j=i;j>0;j--)print(p(j)<1?"":j);}}

Une fonction effectue la vérification de primalité, l'autre fait l'impression. Appelez-le part(7)

Non golfé

La première fonction effectue la vérification de primalité. Il renvoie un intau lieu d'un booleancar de cette façon, plus d'octets sont enregistrés. ( intau lieu de boolean, 0au lieu de false, 1au lieu de true)

int Q103891p(int n){
  for(int k=1;++k<=sqrt(n);)
    if(n%k<1)return 0;
  return 1;
}

La deuxième fonction imprime la chaîne. Il parcourt chaque nombre, s'il n'est pas un nombre premier, passez à l'itération suivante. S'il s'agit d'un nombre premier, il continue jusqu'à l'impression dans une autre forboucle. Encore une fois, si le nombre est premier, nous l'imprimons, sinon non.

void Q103891(int n){
  for(int i=1,j;i<=n;i++){
    if(p(i)<1)continue;
    for(j=i;j>0;j--)
      print(p(j)<1?"":j);
  }
}

Gelée , 12 octets

ÆR;@1
ÇÇ€UVV

Essayez-le en ligne!

S'il n'y avait pas eu de 1s du tout, mon code n'aurait été que ÆRÆRUVVpour 7 octets.

Explication améliorée:

ÇÇ€UVV Main link. Arguments: z.
Ç      Run link1 on z.
 ǀ    Run link1 on z's elements.
   U   Reverse z's elements.
    V  Flatten z.
     V Concatenate z's elements.

ÆR;@1 Link 1. Arguments: z.
ÆR    Range of primes [2..z].
    1 Integer: 1.
  ;@  Concatenate x to y.

Le gars irlandais (appelé Dennis?) M'a en quelque sorte dépassé lol.

05AB1E , 19 octets

LDpÏX¸ì€Lí˜ÐXQsp+ÏJ

Essayez-le en ligne!

Explication

L                     # range [1 ... input]
 DpÏ                  # keep only primes
    X¸ì               # prepend a 1
       €L             # map: range [1 ... n]
         í            # reverse each sublist
          ˜           # flatten list to 1D
           Ð          # triplicate
            XQ        # check elements in one copy for equality with 1
              sp      # check elements in one copy for primality
                +     # add the above lists giving a list with true values at indices
                      # comtaining 1 or a prime
                 Ï    # keep only those elements of the unmodified copy of the list
                  J   # join

Brachylog , 17 octets

y:{e1|e#p}f@[rcw\

Essayez-le en ligne!

Je ne peux pas sembler devenir plus court que ça ...

Explication

y                      The list [0, ..., Input]
 :{      }f            Find all...
   e1                     ...elements that are 1 (there is 1)...
     |                    ...or...
      e#p                 ...elements that are prime...
           @[          Take a prefix of the result
             rc        Reverse it and concatenate it into a number
               w       Write to STDOUT
                  \    Backtrack: try another prefix

Langue GameMaker, 169 octets

Fonction principale (68 octets)

b=""for(i=1;i<=argument0;i++){c=i while(j)b+=string(p(c--))}return b

Fonction p (46 octets)

for(a=0;a<argument0;a++)while q(++b){}return b

Fonction q (55 octets)

n=argument0 for(i=2;i<n;i++)if!(n mod i)p=1return p|n=1

MATL , 15 octets

Zq"1@ZqP]1v!VXz

Essayez-le en ligne!

Zq      % Implicit input. Push array of primes up to that value
"       % For each prime in that array
  1     %   Push 1
  @     %   Push current prime
  Zq    %   Push array of primes up to that
  P     %   Reverse
]       % End
1       % Push 1
&h      % Concatenate all stack horizontally
V       % Convert to string
Xz      % Remove spaces. Implicit display

Perl 6 , 41 octets

{[~] flat [\R,] 1,|grep *.is-prime,2..$_}

( Essayez-le en ligne. )

Explication:

• 1, |grep(*.is-prime, 2..$_): Séquence de 1 et nombres premiers ... (1 2 3 5)
• [,] ...: Réduire ("plier") par-dessus l'opérateur virgule ... (1 2 3 5)
• [\,] ...: Avec des résultats intermédiaires ( réduction triangulaire ) ...((1) (1 2) (1 2 3) (1 2 3 5))
• [\R,] ...: Appliquer un méta-opérateur inverseur à la virgule ...((1) (2 1) (3 2 1) (5 3 2 1))
• [~] flat ...: Supprimer l'imbrication de liste et replier l'opérateur de concaténation de chaîne ... 1213215321

(Ceci est basé sur ma réponse pour le défi précédent .)

Mathematica, 61 octets

ToString/@(1<>Prime@Range[Range@PrimePi@#,0,-1]/.Prime@0->1)&

Fonction sans nom prenant un argument entier et renvoyant une chaîne. (Si l'entrée n'est pas un nombre premier, elle "l'arrondit" simplement au nombre premier le plus proche; si l'entrée est non positive, elle prétend que c'est 1.)

Cette implémentation utilise la mauvaise astuce de la réponse de Martin Ender au défi précédent similaire (qui dit que ce vieux chien ne peut pas apprendre de nouvelles astuces?): Abuser <>pour aplatir une liste imbriquée d'entiers.

La liste imbriquée en question commence par générer une liste imbriquée similaire à celle de cette réponse, avec la longueur appropriée (donnée par PrimePi@#, le nombre de nombres premiers jusqu'à et y compris l'entrée); Primeest ensuite appliqué à chaque élément. Par exemple, pour l'entrée 5qui est le 3e nombre premier, le code Range[Range@PrimePi@#,0,-1]donne {{1,0},{2,1,0},{3,2,1,0}}, et en appliquant Primeà chaque élément les rendements {{2,Prime[0]},{3,2,Prime[0]},{5,3,2,Prime[0]}}puisque les 1er, 2e et 3e nombres premiers sont respectivement 2, 3 et 5. Je suis fier d'avoir réussi à ajouter encore plus d'erreurs à l'approche de Martin Ender - Mathematica se plaint à chaque fois qu'il écrit Prime[0].

Prime[0]n'est pas une chose, mais ça va: les /.Prime@0->1transforme tous en 1art. Et nous voulons également un 1sur le front, nous remplaçons donc la ""réponse de Martin Ender par simplement 1, ce qui économise en fait un octet.

PHP, 72 octets

for(;$n<$argv[1];print$s=$n.$s)for($i=2;$i>1;)for($i=++$n;--$i&&$n%$i;);

Run wit -r

panne

for(;$n<$argv[1];               // loop $n up to argument:
    print$s=$n.$s)                  // 2. prepend $n to $s, print $s
    for($i=2;$i>1;)                 // 1. find next prime: break if $i<2
        for($i=++$n;--$i&&$n%$i;);      // if $n is prime, $i is 1 after loop (0 for $n=1)

Pyth - 12 octets

jkf!tPTs}R1S

Suite de tests .