Estou falando sobre essa questão , dê uma olhada se estiver um pouco confuso.

Tarefa principal

Sua tarefa é produzir números inteiros concatenados, em ordem decrescente, mas aumentando o número inteiro máximo toda vez que você clicar 1 (para esta pergunta, 1 será considerado um número primo) . Embora isso não pareça diferente da primeira pergunta, aqui vem a parte complicada: todos os números emitidos podem ser apenas números primos . Eles serão agrupados em uma única sequência, sem espaços ou novas linhas. Sua entrada também será um número primo .

Exemplo:

1
21
321
5321
75321
1175321
Valid output:
1213215321753211175321

Entrada

Seu código pode receber apenas uma entrada: a mais alta prime a ser impressa. Esta entrada pode vir de qualquer lugar (gráfica, STDIN). Você tem certeza de que a entrada é um número primo.

Resultado

Você terá que emitir o número resultante. Você pode obter esse número mantendo a contagem regressiva, conte apenas o número se for primo e conecte todos os resultados a um número. O último número "linha" (por exemplo 7, 5, 3, 2, 1) deve ser impresso totalmente. A saída pode ser qualquer coisa (números, seqüências de caracteres, gráficos), desde que seja legível. O mesmo padrão Regex para verificar seus casos de teste se aplica:

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

Se sua saída não corresponder a esse padrão, seu código é inválido.

Regras

• A entrada é garantida como primária, não inclua manipulação de erros, a menos que você queira / precise.
• A saída pode ser apenas um número totalmente conectado, portanto, não é dividida por nada, nem mesmo novas linhas.
• Seu algoritmo não deve verificar a primeira instância de Nexibição (por exemplo, o 17in 1175321), mas a primeira instância Ncomo o número real.
• Sua entrada é garantida como positiva, não adicione manipulação a menos que você queira / precise.

Casos de teste

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

Vencedora

Isso é código-golfe , então o autor do código com o menor comprimento em bytes vence!

Geléia , 9 bytes

ÆR1;;\UFV

Experimente online!

Como funciona

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

Processando, 161 bytes

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);}}

Uma função faz a verificação de primalidade, a outra faz a impressão. Chame port(7)

Ungolfed

A primeira função faz a verificação de primalidade. Ele retorna um em intvez de um, booleanpois dessa maneira mais bytes são salvos. (em intvez de boolean, em 0vez de false, em 1vez de true)

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

A segunda função imprime a string. Ele itera através de cada número, se não for um primo, pule para a próxima iteração. Se for um primo, continua até a impressão dentro de outro forloop. Novamente, se o número é primo, então o imprimimos, caso contrário não.

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);
  }
}

Gelatina , 12 bytes

ÆR;@1
ÇÇ€UVV

Experimente online!

Se não tivesse sido por 1s, meu código teria apenas ÆRÆRUVV7 bytes.

Explicação aprimorada:

ÇÇ€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.

O cara irlandês (chamado Dennis?) De alguma forma me superou lol.

05AB1E , 19 bytes

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

Experimente online!

Explicação

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

Braquilog , 17 bytes

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

Experimente online!

Não consigo ficar mais curto do que isso ...

Explicação

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

Linguagem do GameMaker, 169 bytes

Função principal (68 bytes)

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

Função p (46 bytes)

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

Função q (55 bytes)

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

MATL , 15 bytes

Zq"1@ZqP]1v!VXz

Experimente online!

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 bytes

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

( Experimente online. )

Explicação:

• 1, |grep(*.is-prime, 2..$_): Sequência de 1 e números primos ... (1 2 3 5)
• [,] ...: Reduza ("dobre") o operador de vírgula ... (1 2 3 5)
• [\,] ...: Com resultados intermediários ( redução triangular ) ...((1) (1 2) (1 2 3) (1 2 3 5))
• [\R,] ...: Aplique o meta-operador de reversão à vírgula ...((1) (2 1) (3 2 1) (5 3 2 1))
• [~] flat ...: Remova o aninhamento de lista e dobre o operador concat de cadeia ... 1213215321

(Isso se baseia na minha resposta para o desafio anterior .)

Mathematica, 61 bytes

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

Função sem nome, usando um argumento inteiro e retornando uma string. (Se a entrada não for um primo, apenas o arredondará para o primo mais próximo; se a entrada não for positiva, ela fingirá que é 1.)

Essa implementação usa o truque desagradável da resposta de Martin Ender para o desafio anterior semelhante (quem disse que esse cachorro velho não pode aprender novos truques?): Abusar <>de achatar uma lista aninhada de números inteiros.

A lista aninhada em questão começa gerando uma lista aninhada semelhante à da resposta, com o comprimento apropriado (fornecido por PrimePi@#, o número de primos até e incluindo a entrada); então Primeé aplicado a todos os elementos. Por exemplo, para a entrada 5que é o terceiro primo, o código Range[Range@PrimePi@#,0,-1]produz {{1,0},{2,1,0},{3,2,1,0}}e a aplicação Primea cada elemento produz {{2,Prime[0]},{3,2,Prime[0]},{5,3,2,Prime[0]}}desde o primeiro, segundo e terceiro primos são 2, 3 e 5, respectivamente. Sinto-me orgulhoso por ter conseguido adicionar ainda mais erros à abordagem de Martin Ender - o Mathematica reclama toda vez que escreve Prime[0].

Prime[0]não é uma coisa, mas tudo bem: /.Prime@0->1transforma todos eles em 1s. E também queremos um 1na frente, por isso substituímos a ""resposta de Martin Ender por simplesmente 1, o que realmente salva um byte.

PHP, 72 bytes

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

Run wit -r

demolir

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)

Pitão - 12 bytes

jkf!tPTs}R1S

Conjunto de Teste .