Problema de 9 dígitos


8

Escreva um programa para encontrar um número composto por 9 dígitos, no qual cada um dos dígitos de 1 a 9 aparece apenas uma vez. Esse número também deve atender a esses requisitos de divisibilidade:

  1. O número deve ser divisível por 9.
  2. Se o dígito mais à direita for removido, o número restante deverá ser divisível por 8.
  3. Se o dígito mais à direita do novo número for removido, o número restante deverá ser divisível por 7.
  4. E assim por diante, até que haja apenas um dígito (que será necessariamente divisível por 1).

Crédito Dávid Németh


28
A primeira regra parece desnecessária. Qualquer número que consiste de dígitos 1-9 uma vez que cada um irá sempre ser divisível por 9.
Geobits

6
Qual é o aspecto do código aqui? Parece que isso poderia ser publicado em Puzzling
Simon Forsberg

11
Mesmo se formos chamar de "brecha padrão", os desafios do código de golfe que produzem uma saída fixa geralmente menor do que qualquer código que possa construí-lo geralmente não são particularmente interessantes.
Ry-

9
O problema que tenho com desafios como esse é que a fronteira entre a codificação e a aplicação de propriedades matemáticas é vaga. Por exemplo, a regra de divisibilidade para 5 é que o número deve terminar em 0 ou 5. Restringir as opções para esse dígito a 0 e 5 é parte integrante da saída? Ficaria ainda pior se estivéssemos lidando com números de 10 dígitos.
User2357112 suporta Monica

4
@Sylwester O que você fez é supor que há apenas uma maneira de resolver o problema, porque você tem medo de quebrar a brecha. "Repetir os requisitos de verificação de números". Isso exclui completamente quaisquer exemplos interessantes. E a pergunta é: "Qual idioma pode verificar essas coisas e fazer o menor número possível de caracteres".
Cruncher

Respostas:


9

CJam - 26

1{;9,:)_mrs0@{_3$<i\%+}/}g

É aleatório, mas funciona muito rápido com o interpretador java . Pode levar alguns minutos com o intérprete online .

Explicação:

1empurra 1 (a ser explicado mais adiante)
{…}gé um loop do-while
;remove um valor da pilha (inicialmente o 1 com o qual começamos)
9,faz com que o array [0 ... 8]
:)incremente os elementos do array, resultando em [1 ... 9]
_duplica o array
mrembaralha o array
sconverte em string
0@0 e depois coloca a outra cópia do array no topo
{…}/é um loop for-each (sobre os números 1 ... 9)
_duplica o número atual (vamos chamá-lo de "k" )
3$copia a sequência numérica da pilha
<iobtém a substring com os primeiros k caracteres, depois converte em
\%swaps inteiros com a outra cópia de k e obtém o restante (% k)
+adiciona o restante ao valor anterior na pilha (inicialmente 0 a partir de cima )
Neste ponto, temos a sequência numérica na pilha, seguida de um 0 se o número corresponder a todos os requisitos (ou seja, todos os restantes foram 0) ou um valor diferente de 0.
A parte superior da pilha se torna a condição de loop do-while. Ele é acionado e o loop continua se a condição for verdadeira.
Se encontrarmos a solução, a condição é 0 (false), o loop termina e o restante da pilha (a sequência numérica) é impressa.
Se não for a solução, a condição é o valor diferente de 0 (true) e o loop continua com a sequência na pilha. A string é exibida no início da próxima iteração (então o loop espera um valor na pilha, e esse é o motivo do 1 inicial).

Obrigado Dennis por tornar o código mais curto e complicado: p


Agradável! Você pode salvar mais um byte usando um valor fictício:0{;9,:)_mrsT@{_3$<i\%+}/}g
Dennis

7

Javascript (E6) 105 125 134

Construção recursiva do número, cada etapa verifica a divisibilidade.
Tempo de execução próximo a 0 s
Sem E / S neste momento, pois o OP solicitou que um programa localizasse o número, e o número é encontrado e registrado automaticamente no console

Golf mais Cortesia de MT0

(Q=(n,d,b)=>([(m=n+(s=[...b]).splice(i,1))%d||Q(m,d+1,s)for(i in b)],d>9&&(Q.z=n),Q.z))('',1,'123456789')

Golfe

(Q=(n='',d=1,b=[...'123456789'],i)=>{
for(i=0;s=[...b],m=n+s.splice(i,1),b[i];i++)m%d||Q(m,d+1,s);d>9&&(Q.z=n);return Q.z;
})()

Feio

(Q=(n='', d=1, b=[...'123456789'], i) => {
   for(i=0; s=[...b], m=n+s.splice(i,1), b[i]; i++)
     m % d || Q(m,d+1,s);
   d > 9 && (Q.z=n);
   return Q.z;
})()

Bônus

Com três pequenas alterações, você pode usar a mesma função para encontrar números mais longos usando a base> 10. Por exemplo, na base 14 ...

(Q=(n='',d=1,b=[...'123456789ABCD'],i)=>{
  for(i=0; s=[...b], m = n+s.splice(i,1), b[i]; i++)
    parseInt(m,14)%d || Q(m,d+1,s);
  d>13 && (Q.z=n);
  return Q.z;
})()

9C3A5476B812D

Ungolfed

Q=(n,d,b,i,c,z)=>{ // i,c,z fake parameters instead of vars.
  for (i=0; b[i]; i++)
  {
    s=[...b];
    m = n + s.splice(i,1);
    if (m % d == 0)
      if (z = d<9 ? Q(m, d+1, s) : m) return z;
  }
}
Q('',1,[...'123456789'])

1
105 caracteres:(Q=(n,d,b)=>([(m=n+(s=[...b]).splice(i,1))%d||Q(m,d+1,s)for(i in b)],d>9&&(Q.z=n),Q.z))('',1,'123456789')
MT0

101 caracteres:(Q=(n,d,b)=>Math.max(...[(m=n+(s=[...b]).splice(i,1))%d||Q(m,d+1,s)for(i in b)],n))('',1,'123456789')
MT0

@ MT0 uau! A compreensão da matriz é revertida. Vou pegar o primeiro, porque o outro pode encontrar um número errado, se não houver um correto (IE contando até 7 em vez de 9).
Edc65

5

Perl, 56

Uso: perl -E '...'

{$s++;redo if grep{$s!~$_||substr($s,0,$_)%$_}1..9}say$s

Resultado: 381654729

Este programa é realmente lento . Como em mais de 3,5 horas.

Como um exercício mais divertido, decidi desenvolver um algoritmo extremamente rápido:

my $set = [1..9];
for my $divisor (2..9) {
    my $newset = [];
    for my $element (@$set) {
        my $num = $element * 10;
        for (my $digit = $divisor - ($num % $divisor); $digit < 10; $digit += $divisor) {
            if (index($element, $digit) == -1) {
                push @$newset, $num + $digit;
            }
        }
    }
    $set = $newset;
}

print "@$set\n";

O procedimento acima é executado em 0,00095 segundos e confirma que há apenas uma solução para esse problema.


5

Python3, 214, 199, 184, 176, 174, 171, 165, 150146

from itertools import*
g=lambda i,d:d==1!=print(i)or int(i[9:])%d==0!=g(i[:-1],d-1)
for x in permutations("123456789"):g("".join(map(str,x))*2,9)

resultado:

381654729

Este é o meu primeiro roteiro de golfe. Espero que você goste :)


4

Pitão , 33 caracteres

=Y]kFkY~Yf>ql{TlT%vTlTm+k`dr1T)pk

Para testá-lo, coloque o código acima como entrada padrão no link no título.

Após compilar no Python 3.4:

k=''
T=10
Y=[k]
for k in Y:
 Y+=list(filter(lambda T:(len(set(T))==len(T))>(eval(T)%len(T)),
                map(lambda d:k+repr(d),range(1,T))))
print(k)

Explicação:

=Y]k:Y=['']

FkY: para k em F:

~Y: Adicionar a Y

f: Filtrar por

>ql{TlT: Todos os elementos exclusivos e

%vTlT: eval (elemento)% len (elemento) = 0

m+k` d Na lista de k + repr (d)

r1T: para d de 1 a 9.

): Fim do loop

pk: imprimir k


4

Ruby, 66 78 caracteres

[*r=1..9].permutation{|i|r.all?{|x|eval(i[0,x]*"")%x<1}&&$><<i*""}

O tempo de execução é de ~ 8 segundos (saída impressa após 3 s).

Isso não para depois de encontrar o primeiro número; portanto, tecnicamente, imprime todos os números que atendem aos critérios - mas, como existe apenas um número, não faz diferença.

Rubi 1.8, 63

[*r=1..9].permutation{|i|r.all?{|x|eval(i[0,x]*"")%x<1}&&$><<i}

Essencialmente a mesma solução acima. No Ruby 1.8, matrizes são convertidas em strings chamando-as implicitamente Array#join, para que possamos salvar a chamada para isso. Curiosamente, o código também roda muito mais rápido no Ruby 1.8 que 2.0 (tempo total de execução de 4,5 segundos, saída impressa após 1,6 s).


3

GolfScript (35 caracteres)

1,{{10*){.)}8*}%{`..&=},{.`,%!},}9*

Demonstração online

Isso cria prefixos que satisfazem a condição.

# Initial prefixes: [0]
1,
# Loop 9 times
{
    # Extend each prefix by digits 1 to 9
    {10*){.)}8*}%
    # Filter out ones which repeat a digit
    {`..&=},
    # Filter down to ones which are divisible by their length
    {.`,%!},
}9*

3

Haskell 129 121

Aqui está minha tentativa amadora de Haskell (sugestões / melhorias seriam muito apreciadas). Pode não ser o mais curto, mas é executado apenas.19 .65 segundos após as alterações de Flonk no meu sistema.

import Data.List;f=foldl1$(+).(*10);main=print$[f x|x<-permutations[1..9],f[mod(read.take y.show$f x)y|y<-[9,8..1]]<1]!!0

Bem-vindo ao PPCG.SE! Tente adicionar <!-- language: lang-haskell -->duas linhas antes do seu código para destacar a sintaxe!
Flonk

E eu realmente encontrei uma maneira de salvar mais 8 personagens! Em vez de verificar se cada restante == 0, você pode somar todos eles e verificar se esse == 0, que é o mesmo tempo. foldl1Porém, separando a função em, você pode usá-la em vez de sumou any. import Data.List;f=foldl1$(+).(*10);main=print$[f x|x<-permutations[1..9],f[mod(read.take y.show$f x)y|y<-[9,8..1]]<1]!!0
Flonk

Parece que você contou seus caracteres, incluindo a nova linha à direita: existem apenas 128 caracteres no seu código.
Peter Taylor

@Flonk Eu absolutamente amo o uso da ffunção no modpredicado para evitar escrever foldl1, embora os ciclos extras prejudiquem gravemente o desempenho.
DrJPepper

@DrJPepper 0,65 segundos? Meh. Vamos piorar isso! Você também pode substituir !!0por uma chamada para f, que funciona porque há apenas um item na lista. A lista [9,8..1]também pode ser substituída por x, porque o pedido não importa. Fale sobre a reutilização de código!
Flonk

2

Javascript 75 (terminando)

Solução Bruteforce (super lenta)

for(a=c=1;b=c&&++a;)for(c=9;~(a+'').search(c)&&b%c<1;)--c?b=b/10|0:alert(a)

Se você deseja ver o resultado nesta vida útil, atualize o valor inicial para algo como a=c=38e7

Javascript 70 (sem terminação)

for(a=1;b=++a;)for(c=9;~(a+'').search(c)&&b%c<1;)--c?b=b/10|0:alert(a)

E apenas por diversão, uma força bruta aleatória que roda muito mais rápido: (somente ES6)

for(a=i=[..."123456789"];b=c=i&&a.sort(x=>Math.random()*9-5|0).join('');)for(i=9;c%i<1;)--i?c=c/10|0:alert(b)

2

Pitão, 142, 139, 125124

Essencialmente, o mesmo que a solução da @ Ventero, se eu entendi seu código corretamente, mas em Python (grande parte do crédito é para @Greg Hewgill).

from itertools import*;print[s for s in map(''.join,permutations('123456789'))if all(t(s[:i])%i==0 for i in range(1,9))][0]

Você deve poder substituí-lo r(9,1,-1)por r(9), pois a ordem da iteração realmente não importa.
Ventero

Você precisaria usar r(1,9)porque %0é um erro.
Greg Hewgill

@GregHewgill Ah, é claro que você está certo, não percebeu que começa com 0. Acho que é óbvio que não sou especialista em Python. :)
Ventero

@ Ventero Obrigado pela dica, Greg está certo, vou ter que usar r(1, 9)em Python.
Ashwini Chaudhary

1
Usando permutations("123456789")e ''.join(s[:i])é provavelmente menor do que o que você tem (e, em seguida, você pode eliminar r=range)
Greg Hewgill

2

Scala (128 caracteres)

Minha facada nisso ...

Seq(1,2,3,4,5,6,7,8,9).permutations.filter(p=>(2 to 8)forall{n=>(p.take(n).mkString.toLong%n==0)}).map(_.mkString.toLong).toList

Você pode salvar um personagem removendo o espaço entre (2 to 8)e forall.
precisa

@ProgramFOX eu não fazia ideia. Eu sempre pensei que um ponto ou espaço era necessário lá. Obrigado, editei até 128 caracteres.
Keith Pinson

2

Perl, 72

Uso: perl -M5.010 find-9-digits.pl

{$s=join'',sort{4-rand 8}1..9;redo if grep{substr($s,0,$_)%$_}2..9}say$s

Resultado: 381654729

Este programa está lento . Pode levar mais de 10 segundos, porque embaralha os dígitos "123456789", mas o embaralhamento tem uma falha.

Ungolfed:

# Enter a block.
{
     # Shuffle the characters "123456789".
     $s = join('', sort({2 - rand(4)} 1..9));

     # Redo block if any divisiblity test fails; grep returns the
     # number of failing tests.
     redo if grep({
        # For each divisor $_ in 2..9, test if the first $_ digits of
        # of $s are divisible by $_.  The test fails if the remainder
        # is a true value (not zero).
        substr($s, 0, $_) % $_
     } 2..9);
}
say $s;

Joguei o código que embaralha a matriz de dígitos 1..9:

  • use List'Util shuffle;shuffle 1..9 (34 caracteres)
  • sort{(-1,1)[rand 2]}1..9 (24 caracteres)
  • sort{.5<=>rand}1..9 (19 caracteres)
  • sort(2-rand 4}1..9 (18 caracteres)
  • sort{4-rand 8}1..9 (18 caracteres)

O Perl espera que o bloco de classificação compare $ a e $ b de maneira consistente. Meus blocos de ordenação nunca mais olhar para $ a e $ b . Eles retornam uma ordem aleatória para que o tipo se torne um embaralhamento.

Se eu usasse sort{.5<=>rand}1..9, meu programa seria executado mais rapidamente. Esse compara 0,5 com uma flutuação aleatória de 0,0 a 1,0, excluindo 1,0, para uma chance de 1/2 que $ a <$ b , e uma chance de quase 1/2 que $ a> $ b . ( Cuidado: este é um "embaralhamento da Microsoft" , que não é um embaralhamento justo. Isso tem um viés porque .5<=>randnão fornece um pedido consistente.)

Suponha que eu jogue fora um personagem e use muito pior sort(2-rand 4}1..9. O Perl espera que o bloco de classificação retorne um número inteiro, mas 2-rand 4é um número flutuante. É uma flutuação aleatória de -2,0 a 2,0, excluindo -2,0. O Perl trunca esse flutuador em direção a zero, com estes resultados:

  • 1/4 de chance de que $ a <$ b , número inteiro -1 de -2,0 <flutue <= -1,0
  • quase 1/2 chance de que $ a == $ b , número inteiro 0 de -1,0 <flutuante <1,0
  • quase 1/4 de chance de que $ a> $ b , inteiro 1 ou 2 de 1,0 <= float <= 2.0

Quando $ a == $ b , Perl não muda bem. Portanto, meu programa faria mais shuffles, até obter shuffles suficientes onde 2-rand 4não retornava 0 com muita frequência. Meu programa seria tão lento que pode levar mais de um minuto.

Eu uso sort{4-rand 8}1..9, então há apenas uma chance de 1/4 que $ a == $ b , e meu programa usa menos shuffles.


Shuffle enrolado à mão agradável
Miller

1

CJam, 35 bytes

0{)_`$A,1>s=!1$9,{9\m1$\%@+\A/}/;}g

Após aproximadamente 27 minutos, isso produz a seguinte saída:

381654729

Como funciona

0         " Push 0 (“n”).                                                      ";
{         "                                                                    ";
  )_`$    " Increment “N”, duplicate, stringify and sort the resulting string. ";
  A,1>s   " Push '123456789'.                                                  ";
  =!      " Push 0 if the strings are equal and 1 otherwise (“a”).             ";
  1$      " Copy “n”.                                                          ";
  9,{     " For each i in [ 0 1 2 3 4 5 6 7 8 ].                               ";
    9\m   " Calculate “9 - i”.                                                 ";
    1$\%  " Calculate “n % (9 - i)”.                                           ";
    @+    " Add the result to “a”.                                             ";
    \A/   " Swap “a” with “n” and calculate “n / 10”.                          ";
  }/      "                                                                    ";
  ;       " Discard “n”.                                                       ";
}g        " If “a > 0”, repeat the loop.                                       ";

Tamanho impressionante, mas parece ainda mais lento do que o meu, e eu suspeito que não é correta
aditsu sair porque SE é MAU

Eu não entendo completamente, mas parece aceitar 0 como um dígito? Além disso, quando isso pára?
aditsu encerra porque SE é MAU

1

Python 2 (78)

x=1
while len(set(`10*x`))<=9+sum(x/10**i%(9-i)for i in range(9)):x+=1
print x

Não há necessidade de gerar permutações, apenas tente cada número e verifique se seus dígitos mais 0 são distintos. Demora um pouco para correr.


1

SWI-Prolog 84

g([],O,_,O).
g(L,N,I,O):-nth1(_,L,D,R),M is N*10+D,J is I+1,0 is M mod J,g(R,M,J,O).

É um pouco enganador, porque a lista de dígitos precisa ser fornecida na consulta:

?- g([1,2,3,4,5,6,7,8,9],0,0,O).
O = 381654729 ;
false.

No entanto, é o que torna esse código interessante: você pode resolver o problema para qualquer lista de dígitos. Por exemplo:

?- g([1,2,3,4,5,6,7,8,9,0],0,0,O).
O = 3816547290 ;
false.

?- g([1,2,3,4,5,6,7,8],0,0,O).
O = 38165472 ;
false.

?- g([1,2,3,4,5,6,7],0,0,O).
false.

?- g([1,2,3,4,5,6],0,0,O).
O = 123654 ;
O = 321654 ;
false.

?- g([2,2,3,3,5,6,7,8,9],0,0,O).
O = 363258729 ;
O = 363258729 ;
O = 363258729 ;
O = 363258729 ;
O = 723258963 ;
O = 723258963 ;
O = 723258963 ;
O = 723258963 ;
false.

1

Python 2-114

Nem mesmo a menor solução Python, mas estou compartilhando assim mesmo:

e=""
f=lambda s,n:[[n,e.join(f(s.replace(j,e),n+j)for j in s)][s>e],e][n>e>0<int(n)%len(n)]
print f("123456789",e)

1

Bash + coreutils, 159 bytes

l=`echo {1..8}`
for d in {2..8};{
l=$(printf "a=%s;if(!a%%$d)a\n" $(eval echo {${l// /,}}{1..8}|tr \  '
'|grep -Pv '(\d).*\1')|bc|paste -d\  -s -)
}
echo ${l}9

Isso é meio longo, mas acho que o algoritmo é talvez um dos mais rápidos, considerando que este é um script de shell (geralmente lento) que roda em menos de 0,1 segundo.

O algoritmo é mais ou menos assim:

  • Comece com o dígito mais à esquerda (1-8)
  • acrescente o próximo dígito à direita (1-8)
  • remova qualquer número com dígitos repetidos ( grep)
  • verifique a divisibilidade por $d(o número do dígito) usandobc , com uma expressão gerada porprintf
  • Repita o procedimento acima até que um número de 8 dígitos seja obtido

Observe que tomamos alguns atalhos, mas acho que estes são matematicamente sólidos:

  • O dígito mais à esquerda deve ser divisível por 1, que é todos os dígitos, portanto, não verificamos explicitamente o primeiro conjunto de dígitos à esquerda
  • O dígito mais à direita deve ser 9 (na verdade, não tenho certeza se essa é uma suposição válida - vou ter que pensar um pouco)

1

C ++, 187

Eu só tinha que tentar isso em C ++. Obviamente, não será a solução mais curta, mas aqui está:

#include <algorithm>
using namespace std;bool c(int n,int d=9){return d<2||n%d==0&c(n/10,d-1);}int main(){for(char n[]="123456789";next_permutation(n,n+9);)if(c(atoi(n)))return atoi(n);}

retorna o número em vez de imprimi-lo para salvar alguns caracteres (maldita incluir). Nos sistemas POSIX, é claro que isso será convertido em um sinal de 8 bits sem sinal e, portanto, não está correto - mas o programa calculará um número correto.

Ungolfed (requer C ++ 11):

#include <iostream>
#include <algorithm>
using namespace std;

bool check(int n, int digit = 9)
{
  return (n % digit==0) && (digit == 1 || check(n/10,digit-1));
}

int main()
{
  string num {"123456789"};
  while (next_permutation(begin(num), end(num)))
    if (check(stoi(num))){
      cout << num << endl;
      break;
    }
}

1

T-SQL 2005+ - 203

T-sql não é um idioma de golfe muito competitivo ...

with A(n)as(select top 10 number from spt_values where'p'=type),R as(select \r,1l union all select r*10+n,l+1from R,A where n not in(select substring(str(r),n,1)from A)and(r*10+n)%l=0)select max(r)FROM R

Deve ser executado no banco de dados mestre. Você pode substituir o primeiro CTE por isso para torná-lo independente de banco de dados, mas depois usa mais alguns caracteres (e requer 2008)

with A as(select*from(VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9))f(n))

Formação legível:

 with A(n)as(select top 10 number from spt_values where'p'=type),
    R as(select \ r,1 l 
        union all 
        select r*10+n,l+1
        from R,A
        where n not in (
            select substring(str(r),n,1)
            from A
        )
        and(r*10+n)%l=0)
select max(r) FROM R

Basicamente, continuamos adicionando dígitos na parte de trás do rnúmero que ainda não vimos na string e certificando-nos de que a nova string ainda esteja no módulo 0 do nível atual. Inicializamos R para \, este é realmente o único truque neste código. O que é uma maneira louca de defini-lo como 0 no moneytipo de dados. Acho que é uma maneira de você digitar em \vez de moeda. $também faz a mesma coisa no T-SQL, mas $ltenta interpretar uma pseudo coluna que não existe e gera um erro. Isso evita a preocupação de usarinto que causaria um estouro normalmente na 10ª concatenação, forçando-nos a realmente verificar o nível. Edit: Curiosidade O T-sql, mesmo em 2014, não tem uma maneira integrada de transformar uma string em uma tabela de valores (por exemplo, nenhuma função dividida), então também podemos reutilizar nossa Atabela duas vezes para iterar os caracteres no R. restrito

As regras de precedência T-Sql são irritantes, portanto, temos que usar concatenação numérica (* 10 + n), em vez de concatenação de strings.


Você pode salvar 5 bytes e permitir que ele seja executado em todos os tipos de bancos de dados, substituindo a primeira linha por:with A as(select 1n union all select n+1 from A where n<9),
confortavelmenterei

Bom ponto. Em código real, eu nunca usaria um rCTE para contar, para que nem sequer me ocorresse tentar!
Michael B

0

PHP, 89 bytes

versão aleatória, 89 bytes:

for($n=123456789;$n=str_shuffle($n);$d||die("$n"))for($d=10;--$d&&substr($n,0,$d)%$d<1;);

embaralha uma sequência contendo os dígitos e testa a divisibilidade em um loop.

Corra com -nr.


loop de força bruta, 90 bytes, muito lento:

for(;++$i<1e9;$d||die("$i"))for($d=10;--$d&&max(count_chars($i))<2&substr($i,0,$d)%$d<1;);

loops de 100000001, testa a divisibilidade no loop interno e sai quando encontra uma solução.


função recursiva, 94 bytes, muito rápido:

function f($n="",$e=1){while($d++<9)strpos(_.$n,"$d")|($x=$n.$d)%$e||print$e>8?$x:f($x,$e+1);}

acrescenta um dígito que ainda não está no número, se for dada a divisibilidade por comprimento, recursar (ou imprimir).

Isso explora que há apenas uma solução. sem isso, print$e>8?$x:f($x,$e+1)tinha que ser print$e>8?"$x\n":f($x,$e+1)(+3 bytes, imprimir todas as soluções) ou ($e>8?die("$x"):f($x,$e+1))(+4 bytes, sair na primeira solução) ou as soluções seriam impressas sem um delimitador.

Ligue com f();

-

TiO

A versão de força bruta não possui TiO por razões óbvias, mas você pode tentar as outras duas .

O tempo de execução da chamada de função é medido em linha (algo entre 2 e 4 milissegundos);
o tempo de execução total é medido pelo site (geralmente entre 50 e 500 ms).

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.