Görev

Girdi pozitif tamsayı verildiğinde n( 1'den dilinizin sınırına kadar), toplanan maksimum pozitif tamsayı sayısını döndürün veya çıktı alın n.

Test Durumları

Let fgörev göre geçerli işlevi tanımlayın:

f1'den başlayarak dizisi :

1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, ...

Daha büyük bir test örneği olarak:

>>> f(1000000000) // Might not be feasible with brute-forcers
44720

Test Kodu

Açıkça belirtilmeyen test senaryoları için, kodunuzun çıktısı aşağıdakilerin sonucuyla eşleşmelidir:

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        System.out.println((int) Math.floor(Math.sqrt(2*x + 1./4) - 1./2));
    }
}

Çevrimiçi deneyin!

05AB1E , 4 bayt

ÅTg<

Çevrimiçi deneyin!

İş için mükemmel bir araç.

ÅTbir listesini verir Å ll T ve da dahil olmak üzere riangular numaraları N , (ne yazık ki, aksi takdirde 3 bayt olur, çok 0 dahil) g<len alır g inci ve azaltır.

Jöle , 6 5 bayt

R+\»ċ

Çevrimiçi deneyin!

Biraz verimli. Bu sekans üçgen sayılarla artar, bu yüzden n kaç tane üçgen sayının n'den küçük olduğunu sayar .

Açıklama:

        # Main link
R       # Range, generate [1..n]
 +\     # Cumulative sum (returns the first n triangular numbers)
   »    # For each element, return the maximum of that element and 'n'
    ċ   # How many elements are 'n'? (implicit right argument is n)

Haskell , 26 bayt

H.PWiz sayesinde -2 bayt.

(!!)$do x<-[0..];x<$[0..x]

Çevrimiçi deneyin!

Bu, her i'nin i + 1 kez çoğaltıldığı tam sayıların n. Elemanını döndürür .

Brain-Flak , 36 bayt

<>(())({()<(({}())){<>({}[()])}>{}})

Çevrimiçi deneyin!

Bu, standart bölme algoritmasıyla aynı yapıyı kullanır, ancak "bölen" her okunduğunda artırılır.

Pari / GP , 19 bayt

n->((8*n+1)^.5-1)\2

Çevrimiçi deneyin!

Brain-Flak , 82 bayt

"Okunabilirlik" için boşluk eklendi

(())

{
    {}

    ((({})[[]]))

    ([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

}{}{}{}

([]<>)

Çevrimiçi deneyin!

Jöle , 7 bayt

×8‘½’:2

Çevrimiçi deneyin!

Jöle , 9 bayt

Ḥ+4ݤ½_.Ḟ

Çevrimiçi deneyin!

Bu Dennis ve DJ'lerden daha uzun , ama bu sefer bilerek yapıldı . Çok, çok verimli .

R , 28 bayt

function(n)rep(1:n,1:n+1)[n]

Çevrimiçi deneyin!

1Tekrarlanan 2zamanlar, 2tekrarlanan 3zamanlar, ..., ntekrarlanan n+1zamanlar vektörü oluşturur ve nthelemanı alır . Bu, ya 1:nçok büyük ya da n*(n+1)/2 - 1öğelerle tekrarlanan liste çok büyük olduğu için bellek hatasını verecektir .

R , 29 bayt

function(n)((8*n+1)^.5-1)%/%2

Çevrimiçi deneyin!

Alephalpha'nın cevabında bulunan formülü kullanarak değeri doğrudan hesaplar . Bu muhtemelen sayısal hassasiyet dışında herhangi bir sorun olmadan çalışmalıdır.

R , 30 bayt

function(n)sum(cumsum(1:n)<=n)

Çevrimiçi deneyin!

Küçük veya eşit olan üçgen sayıları sayar n. Bu olacak muhtemelen bellek hatası 1:nörneğin en - Büyük yeter 1e9o atar Error: cannot allocate vector of size 3.7 Gb.

APL (Dyalog) , 8 bayt

+/+\∘⍳<⊢

Çevrimiçi deneyin!

TI-Basic, 12 bayt

int(√(2Ans+1/4)-.5

JavaScript (Node.js) , 18 bayt

x=>(x-~x)**.5-.5|0

Çevrimiçi deneyin!

Japt , 8 bayt

Kapalı formül çözümü.

*8Ä ¬É z

Dene

açıklama

8 ile çarpın, 1 ( Ä) ekleyin, kare kökü ( ¬) alın, 1 ( É) çıkarın ve sonucu 2 ( z) ile bölün .

Alternatif, 8 bayt

Port DJMcMayhem Jelly çözüm .

õ å+ è§U

Dene

1'den õgirişe bir tamsayılar dizisi ( å) oluşturun, ekleyerek ( +) toplayarak kümülatif olarak azaltın è( §) ve input ( U) 'a eşit veya ondan ( ) eşit olan öğeleri sayın ( ).

Befunge, 32 20 bayt

1+::1+*2/&#@0#.-`#1_

Çevrimiçi deneyin!

Brain-Flak , 70 56 48 bayt

{([(({}[({}())()])[()])]<>){<>({}())}{}<>{}}<>{}

Çevrimiçi deneyin!

açıklama

Bunun ana kısmı yazdığım şu snippet'tir:

([(({})[()])]<>){<>({}())}{}<>{}

Hizmet Şartları pozitifse ve yığınları başka şekilde değiştirirse bu hiçbir şey yapmaz. Bu edilir Süper kirli yığını ama işe yarıyor. Şimdi programın ana kısmı, girdi pozitif olmayana kadar girdiden giderek daha büyük sayıları çıkarır. Akümülatörü her defasında 1'den başlayarak akümülatörden girişten 1 daha fazla çıkarıyoruz.

({}[({}())()])

Bunu yukarıdaki pasajın içine koyabiliriz

([(({}[({}())()])[()])]<>){<>({}())}{}<>{}

Bu, bir döngüye konur, böylece yığınları değiştirene kadar yürütülür. Döngü bittiğinde, akümülatörü yığınları değiştirerek ve önemsizleri kaldırarak alırız.

Pyth , 7 bayt

lh{I#./

Çevrimiçi deneyin!

Filtre tamsayı bölümlerini sakla ITekilleştirme üzerinde değişken ead'i halın ve ength'i elde edin l.

Geçerlilik kanıtı

_{^{Çok titiz veya iyi ifade edilmiş değil.}}

Let A = bir ₁ + a ₂ + ... + bir _n ve B = ₁ + B ₂ + ... + B _m aynı tamsayı iki ayrı bölmeler olarak , N . A'nın en uzun benzersiz bölüm olduğunu varsayacağız . B'yi tekilleştirdikten sonra , yani aynı tamsayının birden çok örneğini bunlardan sadece biriyle değiştirin, B toplamının N'den az olduğunu biliyoruz . Ama aynı zamanda fonksiyon sonucunun arttığını (kesin olarak değil) biliyoruz, böylece en uzun benzersiz bölümün A'nın her zaman diğer bölümlerdeki benzersiz öğelerin sayısıyla en az aynı miktarda öğeye sahiptir.

Üçgenlik , 49 bayt

....)....
...2)2...
..)1/)8..
.)1/)IE/.
@^)1_+/i.

Çevrimiçi deneyin!

Nasıl çalışır

Üçgenlik, kodun noktaların üçgen dağılımına sahip olmasını gerektirir. Yani, her satırın uzunluğu 2 ile çarpılan ve azaltılan satır sayısına eşit olmalı ve her satırda (her iki tarafta) programdaki konumuna eşit sayıda nokta olmalıdır (alt satır 0, üstündeki satır 1. sıra vb.). Yalnızca birkaç komut vardır ve 'Wiki / Komutlar' sayfasında listelenenlerden başka herhangi bir karakter işlem yapılmaz (dış noktalar, genel şekil olduğu sürece programı hiçbir şekilde etkilemez) programın dikdörtgen kalır).

İki bağımsız değişken komutları için, açıklama boyunca a ve b kullandığımı unutmayın . Bunu akılda tutarak, dolgu için oluşturan tüm yabancı karakterleri kaldırdıktan sonra gerçek programın ne yaptığını görelim:

)2)2)1/)8)1/)IE/@^)1_+/i | Input from STDIN and output to STDOUT.

)                        | Push a 0 onto the stack. Must precede integer literals.
 2                       | Push ToS * 10 + 2 (the literal 2, basically).
  )2                     | Again, push a 2 onto the stack. This can be replaced by D
                         | (duplicate), but then the padding would discard the saving.
    )1                   | Literal 1.
      /                  | Division. Push b / a (1 / 2).
       )8)1              | The literal 8 and the literal 1 (lots of these!).
           /             | Division. Push b / a (1 / 8).
            )IE          | Get the 0th input from STDIN and evaluate it.
               /         | Divide it by 1 / 8 (multiply by 8, but there isn't any
                         | operand for multiplication, and I'm not willing to add one).
                @        | Add 1 to the result.
                 ^       | Exponentiation. Here, it serves as a square too.
                  )1_+   | Decrement (add literal -1).
                      /  | Divide (by 2).
                       i | Cast to an integer.

Alternatif bir çözüm ve dolgu gerekli değilse daha kısa:

....)....
...2)1...
../DD)I..
.E/)4)1/.
+^s_+i...

Çevrimiçi deneyin!

PowerShell 3.0, 45 bayt

[math]::Sqrt(2*$args[0]+.25)-.5-replace'\..*'

Matematik çağrısı acıyor ve PS'nin bankacısının yuvarlanması gerçek şeytandır (bu nedenle bir bayt kaydetmek için kısaltmak için regex'e ihtiyaç duyuyor) ama bu oldukça iyi görünüyor.

Java (JDK) , 28 bayt

n->~-(int)Math.sqrt(8*n+1)/2

Çevrimiçi deneyin!

Örnek gerçekten iyi golf oynamadı çünkü: p

Kredi

• Kevin Cruijssen sayesinde -2 bayt

Jöle , 7 bayt

ŒPfŒṗṪL

Kabaca O (2 ⁿ ) sürede çalışır.

Çevrimiçi deneyin!

Nasıl çalışır

ŒPfŒṗṪL  Main link. Argument: n

ŒP       Powerset; yield all subarrays of [1, ..., n], sorted by length.
   Œṗ    Yield all integer partitions of n.
  f      Filter; keep subarrays that are partitions.
     Ṫ   Tail; extract the last result.
      L  Compute its length.

JavaScript (ES7), 22 19 bayt

n=>(8*n+1)**.5-1>>1

ETHproductions'a -3 bayt teşekkürler.

Dene

o.innerText=(f=
n=>(8*n+1)**.5-1>>1
)(i.value=1000000000);oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o>

açıklama

Girişi 8 ile çarpın ve 1 ekleyin, bunu .5'in gücüne yükseltin, bize kare kökü verin, 1'i çıkarın ve sonucu 1 sağa kaydırın.

Python 2/3, 32 bayt

Kapalı formülü Python uygulaması

lambda n:int((sqrt(1+8*n)-1)//2)

Tamsayı bölümü //2sıfıra yuvarlanır, bu yüzden floor( )gerekli değildir

Haskell , 28 bayt

Biraz sıkıcı, ama diğer Haskell çözümünden oldukça kısa ve gerçekten hoş bir ifade içermiyor. Ne yazık ki tip sistemi engellemeden daha kısa olamazdı:

g x=floor$sqrt(2*x+0.25)-0.5

Çevrimiçi deneyin!

Pointfree, 33 bayt

ceiling.(-0.5+).sqrt.(0.25+).(2*)

Alternatif olarak, 33 bayt

Pointfree sürümü ile aynı uzunlukta, ama çok daha ilginç.

g n=sum[1|x<-scanl1(+)[1..n],n>x]

Samanyolu , 12 bayt

'8*1+g1-2/v!

açıklama

code         explanation       value

'            push input        n          
 8*          push 8, multiply  8n
   1+        add 1             8n+1
     g       square root       sqrt(8n+1)
      1-     subtract 1        sqrt(8n+1)-1
        2/   divide by 2       (sqrt(8n+1)-1)/2
          v  floor             floor((sqrt(8n+1)-1)/2)
           ! output

Pyt , 7 5 bayt

Đř△>Ʃ

Açıklama:

                      Implicit input
Đř△                   Gets a list of the first N triangle numbers
   >                  Is N greater than each element in the list? (returns an array of True/False)
    Ʃ                 Sums the list (autoconverts booleans to ints)

Daha hızlı, ancak daha uzun yol

Pyt , 11 9 bayt

Đ2*√⌈ř△>Ʃ

Açıklama:

Đ2*√⌈ř△           Gets a list of triangle numbers up to the ceiling(sqrt(2*N))-th
       >          Is N greater than each element of the list? (returns an array of True/False)
        Ʃ         Sums the array

Alternatif yol - liman Shaggy'nin cevabının

Pyt , 8 7 bayt

8*⁺√⁻2÷

J , 11 bayt

2&!inv<.@-*

Çevrimiçi deneyin!

2&!inv       solve [x choose 2 = input]
         -*  minus 1
      <.     and floor

Boşluk , 111 bayt

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_integer_from_STDIN][T T   T   _Retrieve_input][S S S T    S S S N
_Push_8][T  S S N
_Multiply][S S S T  N
_Push_1][T  S S S _Add][S S T   T   N
_Push_n=-1][N
S S N
_Create_Label_SQRT_LOOP][S S S T    N
_Push_1][T  S S S _Add][S N
S _Duplicate_n][S N
S _Duplicate_n][T   S S N
Multiply][S T   S S T   S N
_Copy_0-based_2nd_(the_input)][S S S T  N
_Push_1][T  S S S _Add][T   S S T   _Subtract][N
T   T   N
_If_negative_jump_to_Label_SQRT_LOOP][S S S T   S N
_Push_2][T  S S T   _Subtract][S S S T  S N
_Push_2][T  S T S _Integer_divide][T    N
S T _Print_integer]

Harfler S(boşluk), T(sekme) ve N(yeni satır) yalnızca vurgulama olarak eklendi.
[..._some_action]yalnızca açıklama olarak eklendi.

Çevrimiçi deneyin (yalnızca ham alanlar, sekmeler ve yeni satırlarla).

Sahte kodda açıklama:

Formülü kullanır:

NOT: Beyaz alanın karekök yerleşikliği yoktur, bu yüzden bunu manuel olarak yapmalıyız.

Integer i = read STDIN as integer
i = i * 8 + 1
Integer n = -1
Start SQRT_LOOP:
  n = n + 1
  If(n*n < i+1):
    Go to next iteration of SQRT_LOOP
n = (n - 2) integer-divided by 2
Print n as integer to STDOUT

Vitsy , 16 bayt

2*14/+12/^12/-_N

Çevrimiçi deneyin!

Karışıma kendi katkımı da ekleyebilirim. Bu, Vitsy'deki bölüm yineleme çözümünden daha kısadır.

Oasis , 14 bayt

n8*1+1tm1%_b+0

Çevrimiçi deneyin!

Nasıl?

n8*1+           8n + 1
     1tm        sqrt
        1%_     integer?
           b+   add f(n-1)

             0  f(0) is 0

Bu, girdi 0 için 0 ile başlayarak üçgen bir indeksle karşılaştığında sonucu arttıran özyinelemeli bir çözümdür.

Perl 5,19 -p (++) bayt

$_=0|-.5+sqrt$_*2+1

Çevrimiçi deneyin!

Yakut , 27 bayt

Birinin fiyatı için üç. Daha kısa gidemediğim için hayal kırıklığına uğradım.

->n{a=0;n-=a+=1while n>a;a}

->n{((8*n+1)**0.5-1).div 2}

->n{((n-~n)**0.5-0.5).to_i}

Çevrimiçi deneyin! (işlevi seçmek için önüne f = ekleyin)