compito

Il tuo compito è costruire una struttura con $n$ cubi. Il volume dei cubi segue la seguente sequenza (in basso -> in alto)

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

ingresso

Il volume totale della struttura ( $V$ ).

produzione

valore di ( $n$ ), ovvero: il numero totale di cubi.

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

Appunti

L'input sarà sempre un numero intero.
A volte non è possibile seguire la sequenza, ovvero: non rappresenta un valore specifico per . In tal caso, restituisci -1 o un valore errato di tua scelta (è tuttavia necessaria la coerenza). $V$ $n$
Questo è code-golf quindi la risposta più breve in byte per ogni lingua vince.
Nessuna risposta verrà contrassegnata come accettata per il motivo sopra indicato.

richieste

Questa è la mia prima sfida sul sito, quindi abbi pazienza e perdona (e raccontami) di tutti gli errori che ho commesso.
Si prega di fornire un collegamento in modo che il codice possa essere testato.
Se puoi, scrivi gentilmente una spiegazione su come funziona il tuo codice, in modo che altri possano capire e apprezzare il tuo lavoro.

esempi

input  : 4183059834009
output : 2022

input  : 2391239120391902
output : -1

input  : 40539911473216
output : 3568

Grazie a @Arnauld per il link a questo:

Non è carino.

Collegamento a originale: collegamento

code-golf math

— Utente Any3nymous
fonte

2

Questa è una prima sfida ben scritta. Tuttavia, consiglio vivamente di aggiungere alcuni casi di test.

— Arnauld,

1

@Arnauld, ok ci sto lavorando proprio adesso e grazie :)

— Qualsiasi utente Any3nymous il

OEIS A000537

— JayCe

Potete per favore spiegare come input 4183059834009dà output 2022?

— DimChtz,

2

@ SuperJedi224 AFAIK la regola predefinita è "qualunque sia l'intervallo del tipo intero naturale della tua lingua", ovviamente senza usare un piccolo intervallo per una scappatoia - almeno questo è quello che ho assunto nella mia risposta: o

— Felix Palmen,

19

JavaScript (ES7), 31 byte

Una formula diretta Restituisce 0se non c'è soluzione.

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

Provalo online!

Come?

La somma dei primi cubi è data da: $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$

(Questo è A000537 . Questa formula può essere facilmente dimostrata per induzione. Ecco una bella rappresentazione grafica di ) $S_5$

Alternativamente, se è la somma dei primi cubi, la seguente equazione ammette una soluzione intera e positiva: $v$ $x$

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

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

Perché è positivo, ciò porta a: $(x^2+x)/2$

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

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

La cui soluzione positiva è data da:

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

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

Se $r=\sqrt{\Delta}$ è un numero intero, è garantito che sia dispari, poiché stesso è dispari. Pertanto, la soluzione può essere espressa come: $\Delta$

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

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

Commentate

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)

Versione ricorsiva, 36 35 byte

Restituisce NaNse non c'è soluzione.

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

Provalo online!

Commentate

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

Ciao, ho creato un link di risposta (alla mia domanda) , dal momento che hai pubblicato prima volevo chiedere, va bene pubblicare due volte nella stessa lingua?

— Utente Any3nymous

@ Any3nymoususer Pubblicare diverse risposte nella stessa lingua va benissimo. Rispondere alla propria sfida non dovrebbe essere fatto prima di un paio di giorni, ma suppongo che ora sia OK.

— Arnauld,

Oh, in quel caso grazie per

— avermelo

7

05AB1E , 6 byte

ÝÝOnIk

Provalo online!

La risposta della gelatina di Port of Jonathan. Prendere la somma cumulativa di [0 ... n] , quadrati ciascuno e trovare l'indice di V .

05AB1E , 7 byte

ÝÝ3mOIk

Provalo online!

Come funziona

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

8 byte alternativa: ÝÝÅΔ3mOQ.

— Mr. Xcoder
fonte

Non ho idea del perché entrambi 3mOe nOfunzionino ... Probabilmente anche menzionare -1 è il valore errato.

— Magic Octopus Urn,

6

R , 42 40 byte

-2 byte grazie a Giuseppe

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

Provalo online!

La risposta JavaScript di Port of Arnauld . Restituisce anche 0 se non c'è soluzione.

— duckmayr
fonte

Buona cattura @Giuseppe!

— duckmayr,

1

vota per R come lingua del mese!

— Giuseppe,

@Gio Giuseppe fatto!

— duckmayr,

5

Gelatina , 5 4 byte

RÄ²i

Un collegamento monadico, cede 0se non è possibile.

Provalo online!troppo inefficiente per i casi di test! (O (V) spazio: p)

Ecco una versione a 8 byte che esegue prima una radice cubica di V per renderla O (V ^ (1/3)). Utilizzando quella versione a 8 byte qui è una suite di test

Come?

Σ_{io = 1}^{io = n} {io}^{3} = {(Σ_{io = 1}^{io = n} io)}^{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

È valido? dal momento che non è in grado di gestire l'input mostrato nei casi di test? (Non ne ho idea)

— Utente Any3nymous il

1

È valido, è solo l'intervallo che genera un errore di memoria per quei casi di test. Prova valori più piccoli come36

— Mr. Xcoder,

1

@ FiveCrayFish973 sì, è del tutto normale sacrificare l'usabilità / efficienza / ecc. Per il conteggio dei byte nel code-golf (a meno che la specifica non imponga alcuni limiti). Vedere la versione a 9 byte per quella che funziona per i casi di test.

— Jonathan Allan,

@JonathanAllan, non sapevo cosa suggerissero le regole di questa community. Se è valido, è valido. Saluti

— Utente Any3nymous il

Peccato si Ä²icomporta come ²⁼( Ị, in altre parole).

— Erik the Outgolfer,

4

Elisir , 53 byte

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

Provalo online!

La risposta della gelatina di Port of Jonathan.

Elisir , 74 byte

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

Provalo online!

Decisamente non ottimale. Ma sono solo un principiante elisir! :) Restituisce nilper valori "non validi" di V.

— Mr. Xcoder
fonte

3

Japt, 7 byte

o³å+ bU

Provalo

Spiegazione

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

Alternativa

Çõ³xÃbU

Provalo

— ispido
fonte

3

Cubix , 27 byte (o volume 27?)

Sembra il posto giusto per questa lingua.

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

Provalo online!

Questo si avvolge su un cubo 3x3x3 come segue

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

Guarda correre

È essenziale forze brute allontanando i cubi crescenti dall'input. Se risulta zero, emettere naltrimenti in caso di risultati negativi, stampare 0 ed uscire.

— MickyT
fonte

2

Perl 6 , 30 29 26 byte

-4 byte grazie a Jo King

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

Provalo online!

Soluzione a forza bruta per n <10000. Utilizza l'equazione della risposta di Jonathan Allan. 37 36 byte soluzione per n maggiore ( -1 byte grazie a Jo King ):

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

Provalo online!

ritorna Falsese non c'è soluzione.

Spiegazione

               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

Per la forza bruta, potresti fare 0..$_in modo di essere valido per tutti i numeri, anche se scadrà su quelli più grandi. Per giocare a golf normale, puoi rimuovere il .primo e cambiare il secondo da 0>=*a1>*

— Jo King

26 byte

— Jo King,

2

JavaScript (Node.js) , 28 byte

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

Provalo online!

So che è la mia domanda e tutto il resto, ma ho avuto una risposta migliore (per questa lingua) quindi è presente, quindi ho pubblicato. Spero sia ok

— Utente Any3nymous
fonte

1

APL (Dyalog) , 18 byte

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

Provalo online!

— Uriel
fonte

1

Matlab, 27 byte

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

Restituisce nif esiste o una matrice vuota in caso contrario.

Come funziona

            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

Provalo online!

Nota Non riesce per grandi vmotivi a causa di limiti di memoria.

— DimChtz
fonte

1

Python 3 , 60 byte

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

Provalo online!

-6 grazie a Mr. Xcoder .

Se riusciamo a lanciare un errore nel caso in cui non ci sia $n$ per un particolare $V$ , possiamo ottenere questo fino a 51 byte:

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

Provalo online!

— Erik the Outgolfer
fonte

1

Perl 6 , 33 byte

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

Provalo online!

Questo utilizza il metodo di Arnauld . Restituisce un oggetto vuoto se il numero non è valido.

— Jo King
fonte

1

dc , 19 byte

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

Input e output provengono dallo stack, restituisce 0 se nessuna soluzione.

Provalo online!

Spiegazione

Se esiste una soluzione n, l'input è ((n^2+n)^2)/4. Quindi dovremo calcoliamo una soluzione di prova come n=sqrt(sqrt(4*input)), utilizzando di default 0 dc decimale di precisione per le radici quadrate, quindi confrontare (n^2+n)^2per 4*inputvedere se è in realtà una soluzione.

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

La penultima linea si basa sul fatto non ovvio che a dc, 0^x=0per tutti diversi da zero x(anche negativo x!) Ma 0^0=1.

— Sophia Lechner
fonte

1

Python 3 , 53 48 byte

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

Provalo online!

-3 byte da Jo King

Restituisce -1per nessuna risposta.

Funziona solo n=997con i limiti di ricorsione predefiniti.

Prende ripetutamente cubi sempre più grandi dal volume fino a quando non arriva a zero (esito positivo, restituisce il numero di cubi rimossi) o un numero negativo (nessuna risposta).

Spiegazione:

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/oro gli elenchi sono generalmente più brevi di if/else. 50 byte

— Jo King,

@JoKing Grazie! Ho anche rimosso altri due byte.

— pizzapants184,

not V=> V==0oppureV>-1

— Jo King,

0

gvm (commit 2612106 ) bytecode, 70 59 byte

(-11 byte moltiplicando in un ciclo invece di scrivere il codice per moltiplicare due volte)

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

Esecuzioni di test:

> 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

Non proprio un punteggio basso, sto solo usando questa bella domanda per i test gvmqui;) Il commit è più vecchio della domanda ovviamente. Nota che si tratta di una macchina virtuale a 8 bit, quindi utilizzando un codice che gestisce solo l'intervallo di numeri non firmati naturali 0-255, i casi di test indicati nella domanda non funzioneranno.

Assemblato manualmente da questo:

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 : Ho appena risolto un bug in gvm; senza questa correzione, ho gvmprovato a leggere i programmi binari in modalità testo , che potrebbe rompersi (il codice sopra non contiene alcun 0xdbyte, quindi non si romperà su Windows senza questa correzione).

— Felix Palmen
fonte

0

K (oK) , 21 byte

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

Provalo online!

La risposta JS di Port of Arnauld .

Come:

{(,_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.

la funzione restituirà (_r%2)iff 1!r == 0, altrimenti restituisce null ( 0N). Ciò è dovuto al singolo elemento nell'elenco con indice 0 e il tentativo di indicizzare tale elenco con qualsiasi numero diverso da 0 restituirà null.

— J. Sallé
fonte

Quanti cubi possono essere costruiti

compito

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

ingresso

produzione

Appunti

richieste

esempi

JavaScript (ES7), 31 byte

Come?

Commentate

Versione ricorsiva, 36 35 byte

Commentate

05AB1E , 6 byte

05AB1E , 7 byte

Come funziona

R , 42 40 byte

Gelatina , 5 4 byte

Come?

Elisir , 53 byte

Elisir , 74 byte

Japt, 7 byte

Spiegazione

Alternativa

Cubix , 27 byte (o volume 27?)

Perl 6 , 30 29 26 byte

Spiegazione

JavaScript (Node.js) , 28 byte

APL (Dyalog) , 18 byte

Matlab, 27 byte

Python 3 , 60 byte

Perl 6 , 33 byte

dc , 19 byte

Spiegazione

Python 3 , 53 48 byte

gvm (commit 2612106 ) bytecode, 70 59 byte

K (oK) , 21 byte

Come:

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