tarefa

Sua tarefa é construir uma estrutura com cubos. O volume de cubos segue a seguinte sequência (inferior -> superior) $n$

$n^3, (n-1)^3, (n-2)^3,...,1^3$

entrada

O volume total da estrutura ( ). $V$

saída

valor de ( ), ou seja: O número total de cubos. $n$

$V = n^3 + (n-1)^3 + .... + 1^3$

notas

A entrada sempre será um número inteiro.
Às vezes, não é possível seguir a sequência, ou seja: não representa um valor específico para . Nesse caso, retorne -1 ou um valor falso de sua escolha (embora seja necessária consistência). $V$ $n$
Este é o código-golfe, pelo que a resposta mais curta em bytes para cada idioma vence.
Nenhuma resposta será marcada como aceita pelo motivo acima mencionado.

solicitações de

Este é o meu primeiro desafio no site, então tenha paciência comigo e perdoe (e conte-me) os erros que cometi.
Forneça um link para que seu código possa ser testado.
Se puder, escreva uma explicação sobre como seu código funciona, para que outras pessoas possam entender e apreciar seu trabalho.

exemplos

input  : 4183059834009
output : 2022

input  : 2391239120391902
output : -1

input  : 40539911473216
output : 3568

Obrigado a @Arnauld pelo link para isso:

Isso não é legal?

Link para orignial: Link

code-golf math

— Usuário Any3nymous
fonte

2

Este é um primeiro desafio bem escrito. No entanto, recomendo fortemente adicionar alguns casos de teste.

— Arnauld

1

@ Arnauld, ok, trabalhando nisso agora e obrigado :) #

— Any3nymous user

OEIS A000537

— JayCe

Você pode, por favor, explicar como a entrada 4183059834009fornece saída 2022?

— precisa saber é o seguinte

2

@ SuperJedi224 AFAIK a regra padrão é "o que quer variar o tipo inteiro natural de sua linguagem tem", naturalmente sem o uso de um pequeno intervalo para uma brecha - pelo menos é o que eu assumi em minha resposta: o

— Felix Palmen

19

JavaScript (ES7), 31 bytes

Uma fórmula direta. Retorna 0se não houver solução.

v=>(r=(1+8*v**.5)**.5)%1?0:r>>1

Experimente online!

Quão?

A soma dos primeiros cubos é dada por: $S_n$ $n$

S_{n} = {(\frac{n (n + 1)}{2})}^{2} = {(\frac{n^{2} + n}{2})}^{2}

$S_n = \left(\frac{n(n+1)}{2}\right)^2 = \left(\frac{n^2+n}{2}\right)^2$

(Isso é A000537 . Essa fórmula pode ser facilmente comprovada por indução. Aqui está uma bela representação gráfica de ) $S_5$

Reciprocamente, se é a soma dos primeiros cubos, a seguinte equação admite uma solução inteira positiva: $v$ $x$

{(\frac{x^{2} + x}{2})}^{2} = v

$\left(\frac{x^2+x}{2}\right)^2=v$

Como é positivo, isso leva a: $(x^2+x)/2$

x^{2} + x - 2 \sqrt{v} = 0

$x^2+x-2\sqrt{v}=0$

Cuja solução positiva é dada por:

Δ = 1 + 8 \sqrt{v} x = \frac{- 1 + \sqrt{Δ}}{2}

$\Delta=1+8\sqrt{v}\\ x=\frac{-1+\sqrt{\Delta}}{2}$

Se é um número inteiro, é garantido um número ímpar, porquesi é ímpar. Portanto, a solução pode ser expressa como: $r=\sqrt{\Delta}$ $\Delta$

x = ⌊ \frac{r}{2} ⌋

$x=\left\lfloor\frac{r}{2}\right\rfloor$

Comentado

v =>                    // v = input
  ( r =                 //
    (1 + 8 * v ** .5)   // delta = 1 + 8.sqrt(v)
    ** .5               // r = sqrt(delta)
  ) % 1 ?               // if r is not an integer:
    0                   //   return 0
  :                     // else:
    r >> 1              //   return floor(r / 2)

Versão recursiva, 36 35 bytes

Retorna NaNse não houver solução.

f=(v,k=1)=>v>0?1+f(v-k**3,k+1):0/!v

Experimente online!

Comentado

f = (v,                   // v = input
        k = 1) =>         // k = current value to cube
  v > 0 ?                 // if v is still positive:
    1 +                   //   add 1 to the final result
    f(                    //   do a recursive call with:
      v - k ** 3,         //     the current cube subtracted from v
      k + 1               //     the next value to cube
    )                     //   end of recursive call
  :                       // else:
    0 / !v                //   add either 0/1 = 0 if v is zero, or 0/0 = NaN if v is
                          //   non-zero (i.e. negative); NaN will propagate all the
                          //   way to the final output

— Arnauld
fonte

Olá, criei um link de resposta (para minha própria pergunta) , desde que você publicou primeiro, eu queria perguntar. Tudo bem publicar duas vezes no mesmo idioma?

— Usuário Any3nymous

@ Any3nymoususer A publicação de várias respostas no mesmo idioma está perfeitamente correta. Responder a seu próprio desafio não deve ser feito antes de alguns dias, mas acho que agora tudo bem.

— Arnauld

Ah, nesse caso, thnx, por me dizer :) #

— 318 Any3nymous user

7

05AB1E , 6 bytes

ÝÝOnIk

Experimente online!

Resposta do porto de Jelly's Jonathan. Tomai a soma cumulativa de [0 ... n] , quadrados cada e encontrar o índice de V .

05AB1E , 7 bytes

ÝÝ3mOIk

Experimente online!

Como funciona

ÝÝ3mOIk – Full program.
ÝÝ      – Yield [[0], [0, 1], [0, 1, 2], ... [0, 1, 2, ... V]].
  3mO   – Raise to the 3rd power.
     Ik – And find the index of the input therein. Outputs -1 if not found.

Alternativa de 8 bytes: ÝÝÅΔ3mOQ.

— Mr. Xcoder
fonte

Não tenho idéia do porquê de ambos 3mOe nOtrabalho ... Provavelmente também mencione -1 é o valor falso.

— Magic Octopus Urn

6

R , 42 bytes 40

-2 bytes graças a Giuseppe

function(v,n=((1+8*v^.5)^.5-1)/2)n*!n%%1

Experimente online!

Resposta JavaScript do Port of Arnauld . Também retorna 0 se não houver solução.

— duckmayr
fonte

Boa captura @Giuseppe!

— duckmayr

1

vote em R como idioma do mês!

— Giuseppe

@Giuseppe done!

— Duckmayr

5

Geléia , 5 4 bytes

RÄ²i

Um link monádico produz 0se não for possível.

Experimente online! muito ineficiente para os casos de teste! (O (V) espaço: p)

Aqui está uma versão de 8 bytes que executa uma raiz cúbica de V primeiro para torná-lo O (V ^ (1/3)). Usando essa versão de 8 bytes aqui está uma suíte de testes

Quão?

\sum_{i = 1}^{i = n} i^{3} = {(\sum_{i = 1}^{i = n} i)}^{2}

$\sum_{i=1}^{i=n}i^3=\left(\sum_{i=1}^{i=n}i\right)^2$

RÄ²i - Link: integer, V
R    - range of v -> [1,2,3,...,V]
 Ä   - cumulative sums -> [1,3,6,...,(1+2+3+...+V)]
  ²  - square -> [1,9,36,...,(1+2+3++...+V)²] ( =[1³,1³+2³,1³+2³+3³,...,(1³+2³+3³+...+V³)] )
   i - first 1-based index of v? (0 if not found)

— Jonathan Allan
fonte

Isso é válido? desde que ele não pode manipular a entrada mostrada nos casos de teste? (Eu não tenho nenhuma idéia)

— Any3nymous user

1

É válido, é apenas o intervalo que fornece um erro de memória para esses casos de teste. Tente valores menores como36

— Mr. Xcoder

1

@ FiveCrayFish973 sim, é bastante normal sacrificar a usabilidade / eficiência / etc pela contagem de bytes no code-golf (a menos que a especificação imponha alguns limites). Veja a versão de 9 bytes para uma que funcione nos seus casos de teste.

— Jonathan Allan

@ JonathanAllan legal, eu não sabia o que as regras desta comunidade sugerem. Se é válido, é válido. Cheers

— Any3nymous usuário

Muito ruim Ä²ise comporta como ²⁼( Ịem outras palavras).

— Erik the Outgolfer

4

Elixir , 53 bytes

&Enum.find_index 0..&1,fn n->&1*4==n*n*(n+1)*(n+1)end

Experimente online!

Resposta do porto de Jelly's Jonathan.

Elixir , 74 bytes

fn v->Enum.find_index 0..v,&v==Enum.sum Enum.map(0..&1,fn u->u*u*u end)end

Experimente online!

Definitivamente abaixo do ideal. Mas eu sou apenas um novato em Elixir! :) Retorna nilpara valores "inválidos" de V.

— Mr. Xcoder
fonte

3

Japonês, 7 bytes

o³å+ bU

Tente

Explicação

            :Implicit input of integer U
o           :Range [0,U)
 ³          :Cube each
  å+        :Cumulatively reduce by addition
     bU     :0-based index of U

Alternativo

Çõ³xÃbU

Tente

— Shaggy
fonte

3

Cubix , 27 bytes (ou volume 27?)

Parece o lugar certo para esse idioma.

I@.1OW30pWpP<s)s;;q\.>s-.?/

Experimente online!

Isso envolve um cubo 3x3x3 da seguinte maneira

      I @ .
      1 O W
      3 0 p
W p P < s ) s ; ; q \ .
> s - . ? / . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Assista correr

É essencial as forças brutas afastando os cubos crescentes da entrada. Se resultar em zero, produza uma saída; ncaso contrário, imprima 0 e saia.

— MickyT
fonte

2

Perl 6 , 30 29 26 bytes

-4 bytes graças a Jo King

{first :k,.sqrt,[\+] ^1e4}

Experimente online!

Solução de força bruta para n <10000. Usa a equação da resposta de Jonathan Allan. 37 37 bytes de solução para n maior ( -1 bytes graças a Jo King ):

{!.[*-1]&&$_-2}o{{$_,*-$++³...1>*}}

Experimente online!

Retorna Falsese não houver solução.

Explicação

               o  # Combination of two anonymous Blocks
                {                 }  # 1st Block
                 {               }   # Reset anonymous state variable $
                  $_,*-$++³...1>*    # Sequence n,n,n-1³,n-1³-2³,... while positive
{             }  # 2nd Block
 !.[*-1]&&       # Return False if last element is non-zero
          $_-2   # Return length of sequence minus two otherwise

— Nwellnhof
fonte

Para a força bruta, você pode fazer 0..$_para ser válido para todos os números, mesmo que o tempo limite seja maior. Para o golfe normal, você pode remover o .do primeiro e mudar o segundo de 0>=*para1>*

— Jo King

26 bytes

— Jo King

2

JavaScript (Node.js) , 28 bytes

a=>a**.5%1?0:(2*a**.5)**.5|0

Experimente online!

Eu sei que é a minha própria pergunta e tudo, mas eu tinha uma resposta melhor (para essa lang) que está presente, então eu postei. Espero que esteja tudo bem

— Usuário Any3nymous
fonte

1

APL (Dyalog) , 18 bytes

{o×⍵≥o←⍵⍳⍨+\3*⍨⍳⍵}

Experimente online!

— Uriel
fonte

1

Matlab, 27 bytes

@(v)find(cumsum(1:v).^2==v)

Retorna o n se existe ou uma matriz vazia, se não.

Como funciona

            1:v            % Creates a 1xV matrix with values [1..V]
     cumsum(   )           % Cumulative sum
                .^2        % Power of 2 for each matrix element
                   ==v     % Returns a 1xV matrix with ones where equal to V
find(                 )    % Returns a base-1 index of the first non-zero element

Experimente Online!

Nota Falha grande vdevido a limitações de memória.

— DimChtz
fonte

1

Python 3 , 60 bytes

lambda V:[*[(n*-~n/2)**2for n in range(V+1)],V].index(V)%-~V

Experimente online!

-6 graças ao Sr. Xcoder .

Se pudermos lançar um erro, caso não haja $n$ para um particular $V$ , podemos reduzir isso para 51 bytes:

lambda V:[(n*-~n/2)**2for n in range(V+1)].index(V)

Experimente online!

— Erik, o Outgolfer
fonte

1

Perl 6 , 33 bytes

{$!+>1 if ($!=sqrt 1+8*.sqrt)%%1}

Experimente online!

Isso usa o método de Arnauld . Retorna um objeto Vazio se o número não for válido.

— Brincadeira
fonte

1

dc , 19 bytes

4*dvvdddk*+d*-0r^K*

A entrada e a saída são da pilha, retornam 0 se não houver solução.

Experimente online!

Explicação

Se houver uma solução n, a entrada é ((n^2+n)^2)/4. Então, vamos calcular uma solução julgamento como n=sqrt(sqrt(4*input)), usando padrão 0 decimal de precisão o lugar de dc para raízes quadradas, e depois comparar (n^2+n)^2a 4*inputver se é realmente uma solução.

4*dvv         Calculate a trial solution n (making a copy of 4*input for later use)
dddk          Store the trial solution in the precision and make a couple copies of it
*+d*          Calculate (n^2+n)^2
-             Subtract from our saved copy of 4*input - now we have 0 iff n is a solution
0r^           Raise 0 to that power - we now have 1 if n is a solution, 0 if not
K*            Multiply by our saved trial solution

A penúltima linha se baseia no fato não óbvio de que dc, 0^x=0para todos os que não são zero x(até negativos x!), Mas 0^0=1.

— Sophia Lechner
fonte

1

Python 3 , 53 48 bytes

f=lambda V,n=1:V>0and f(V-n**3,n+1)or(not V)*n-1

Experimente online!

-3 bytes de Jo King

Devoluções -1 sem resposta.

Funciona apenas n=997com os limites de recursão padrão.

Pega repetidamente cubos cada vez maiores do volume até chegar a zero (êxito, número de retorno removido) ou um número negativo (sem resposta).

Explicação:

f=lambda V,n=1: # f is a recursive lambda taking the volume and the cube size (defaulting to 1)

               V>0and               # if the volume is positive
                      f(V-n**3,n+1) # then we are not to the right cube size yet, try again with n+1, removing the volume of the nth cube

                                   or # if V is not positive
                                     (not V)*n-1
                         # case V == 0:
                         # (not V)*n == n; return n-1, the number of cubes
                         # case V < 0:
                         # (not V)*n == 0; return -1, no answer

— pizzapants184
fonte

and/orou listas são geralmente menores que if/else. 50 bytes

— Jo King

@JoKing Thanks! Também tenho mais dois bytes.

— Pizzapants184

not V=> V==0ouV>-1

— Jo King

0

gvm (commit 2612106 ) bytecode, 70 59 bytes

(-11 bytes multiplicando um loop em vez de escrever o código para multiplicar duas vezes)

Hexdump:

> hexdump -C cubes.bin
00000000  e1 0a 00 10 00 1a 03 d3  8a 00 f6 2a fe 25 c8 d3  |...........*.%..|
00000010  20 02 2a 04 0a 01 1a 02  00 00 20 08 4a 01 fc 03  | .*....... .J...|
00000020  d1 6a 02 52 02 cb f8 f4  82 04 f4 e8 d1 6a 03 0a  |.j.R.........j..|
00000030  03 fc d5 a8 ff c0 1a 00  a2 00 c0                 |...........|
0000003b

Execuções de teste:

> echo 0 | ./gvm cubes.bin
0
> echo 1 | ./gvm cubes.bin
1
> echo 2 | ./gvm cubes.bin
-1
> echo 8 | ./gvm cubes.bin
-1
> echo 9 | ./gvm cubes.bin
2
> echo 224 | ./gvm cubes.bin
-1
> echo 225 | ./gvm cubes.bin
5

Não é realmente uma pontuação baixa, basta usar esta boa pergunta para testar gvmaqui;) O commit é mais antigo que a questão, é claro.Observe que essa é uma máquina virtual de 8 bits; portanto, usando algum código que manipule apenas o intervalo de números não assinados naturais 0-255, os casos de teste fornecidos na pergunta não funcionarão.

Montado manualmente a partir disso:

0100  e1         rud                     ; read unsigned decimal
0101  0a 00      sta     $00             ; store to $00 (target sum to reach)
0103  10 00      ldx     #$00            ; start searching with n = #0
0105  1a 03      stx     $03             ; store to $03 (current cube sum)
0107  d3         txa                     ; X to A
                   loop:
0108  8a 00      cmp     $00             ; compare with target sum
010a  f6 2a      beq     result          ; equal -> print result
010c  fe 25      bcs     error           ; larger -> no solution, print -1
010e  c8         inx                     ; increment n
010f  d3         txa                     ; as first factor for power
0110  20 02      ldy     #$02            ; multiply #02 times for ...
0112  2a 04      sty     $04             ; ... power (count in $04)
                   ploop:
0114  0a 01      sta     $01             ; store first factor to $01 ...
0116  1a 02      stx     $02             ; ... and second to $02 for multiplying
0118  00 00      lda     #$00            ; init product to #0
011a  20 08      ldy     #$08            ; loop over 8 bits
                   mloop1:
011c  4a 01      lsr     $01             ; shift right first factor
011e  fc 03      bcc     noadd1          ; shifted bit 0 -> skip adding
0120  d1         clc                     ; 
0121  6a 02      adc     $02             ; add second factor to product
                   noadd1:
0123  52 02      asl     $02             ; shift left second factor
0125  cb         dey                     ; next bit
0126  f8 f4      bpl     mloop1          ; more bits -> repeat
0128  82 04      dec     $04             ; dec "multiply counter" for power
012a  f4 e8      bne     ploop           ; not 0 yet -> multiply again
012c  d1         clc
012d  6a 03      adc     $03             ; add power to ...
012f  0a 03      sta     $03             ; ... current cube sum
0131  fc d5      bcc     loop            ; repeat unless adding overflowed
                   error:
0133  a8 ff      wsd     #$ff            ; write signed #$ff (-1)
0135  c0         hlt                     ; 
                   result:
0136  1a 00      stx     $00             ; store current n to $00
0138  a2 00      wud     $00             ; write $00 as unsigned decimal
013a  c0         hlt

edit : Eu apenas consertei um bug no gvm; sem essa correção, gvmtentei ler programas binários no modo de texto , que podem ser interrompidos (o código acima não contém 0xdbytes, portanto, não será interrompido no Windows sem essa correção).

— Felix Palmen
fonte

0

K (oK) , 21 bytes

{(,_r%2)@1!r:%1+8*%x}

Experimente online!

Resposta JS do Porto de Arnauld .

Quão:

{(,_r%2)@1!r:%1+8*%x} # Main function, argument x
             %1+8*%x  # sqrt(1+(8*(sqrt(x)))
           r:         # Assign to r
         1!           # r modulo 1
        @             # index the list:
 (,_r%2)              # enlist (,) the floor (_) of r modulo 2.

a função retornará (_r%2)iff 1!r == 0, caso contrário, retornará null ( 0N). Isso ocorre porque o elemento único na lista possui o índice 0, e a tentativa de indexar essa lista com qualquer número diferente de 0 retornará nulo.

— J. Sallé
fonte

Quantos cubos podem ser construídos

tarefa

n3,(n−1)3,(n−2)3,...,13n3,(n−1)3,(n−2)3,...,13n^3, (n-1)^3, (n-2)^3,...,1^3

entrada

saída

notas

solicitações de

exemplos

JavaScript (ES7), 31 bytes

Quão?

Comentado

Versão recursiva, 36 35 bytes

Comentado

05AB1E , 6 bytes

05AB1E , 7 bytes

Como funciona

R , 42 bytes 40

Geléia , 5 4 bytes

Quão?

Elixir , 53 bytes

Elixir , 74 bytes

Japonês, 7 bytes

Explicação

Alternativo

Cubix , 27 bytes (ou volume 27?)

Perl 6 , 30 29 26 bytes

Explicação

JavaScript (Node.js) , 28 bytes

APL (Dyalog) , 18 bytes

Matlab, 27 bytes

Python 3 , 60 bytes

Perl 6 , 33 bytes

dc , 19 bytes

Explicação

Python 3 , 53 48 bytes

gvm (commit 2612106 ) bytecode, 70 59 bytes

K (oK) , 21 bytes

Quão:

$n^3, (n-1)^3, (n-2)^3,...,1^3$