Bu cevap-zincirleme görevi , toplamda 7 cevapla Buğday Sihirbazı'nın kazanılmasıyla sonuçlandı . Başka bir cevap kabul edilir, ancak bu meydan okuma için kabul edilen yanıtı veya kazananı etkilemez.

Görev:

xGiriş olarak alınan bir sayının tüm pozitif bölmelerini yazdırın .

Giriş:

xPozitif bölenleri hesaplanması gereken sayı (taban 10'da) olan tek bir sayı .

Çıktı:

Tüm olumlu bölenler x. Herhangi biçimler de dahil izin verilir \n, ,, ;yeter ki anlaşılabilir gibi ayırıcı olarak ve boşluk. Çıktı bir Tamsayılar veya Dizeler dizisi de olabilir (örn [1, 2, 3, 5, 30].). Bölücüleri dilinize stdout, konsol veya eşdeğeri olarak verebilirsiniz veya bir işlevden döndürülebilirler .

kurallar

• Bir kullanıcı arka arkaya iki kez cevap vermeyebilir
• Cevabınız, bir şeyleri başlatmak için 20 karaktere "dönüşebilen" Cevap 2'nin yanı sıra önceki yanıttan en fazla 15 karakter kaldırabilir, ekleyebilir veya değiştirebilir (boşluk sayılmaz)
• Zaten bir cevabı olan bir programlama dilinde cevap göndermenize izin verilmez, istisna o dilin tamamen farklı bir versiyonudur (örneğin: Eğer bir cevap Python 2.7gönderirsem, bir tane gönderebilirsiniz Python 3, ancak giremezsiniz Python 2.6)
• Standart boşluklara izin verilmez
• Sen edilir alma bölenler için inşa eklentileri kullanmasına izin bu meydan uğruna,
• Sen gerekir numarası ve Sorunun başlığında dil adını ve ilgili kişiden değişti karakter sayısını cevabım içerir

puanlama

İşler halledildiğinde en çok gönderime sahip olan kullanıcı kazanır. Beraberlik durumunda, cevaplarından birinde en yüksek puanı alan kullanıcı kazanır. Skorda da bir kravat varsa, en eski gönderime (en yüksek puan alan cevap) sahip olan kullanıcı kazanan ilan edilecektir.

Not: "anlaşınız" <=> 7 Son yanıtın gönderilmesinden bu yana 3 gün geçti

Örnekler:

Input, Output:

14 => [1, 2, 7, 14]
25 => [1, 5, 25]
65 => [1, 5, 13, 65]
114 => [1, 2, 3, 6, 19, 38, 57, 114]

Veya belirtilen koşulları karşılayan herhangi bir eşdeğer çıktı.

Son Not : Cevapları en eskisine göre sıralarsanız bu soru daha iyidir. İlk cevabı Python 2.7'ye göndereceğim, bu yüzden ikinci cevabı buna bağlı olarak göndermelisiniz. İyi şanslar ve iyi eğlenceler!

Liderler Sıralaması:

Bu liste eskimiş olabilir, düzenlemek için serbest bırakılmış olabilir:

1) Buğday Sihirbazı [Güncel Lider 🏆] : 7 cevaplar - Python 1.6 , 05AB1E , Aslında , Del | m | t , DSF , Beyin Flak , yüksek oranlarda konuşma

2) Riley: 3 cevap - Cidden , CJam , 2sable

3) Jonathan Allan: 2 cevap - Python 3 , Jelly

3) ETHproductions: 2 cevap - Japt , Pyth

3) Mistah Figgins: 2 cevap - Befunge-98 , Brain-Flak Classic

6) Riker: 1 cevap - MATL

6) dzaima: 1 cevap - SOGL 0.8.2

6) LegionMammal978: 1 cevap - Boşluk

6) Nick Clifford: 1 cevap - Ohm

6) Lynn: 1 cevap - GolfScript

6) MickyT: 1 cevap - Cubix

Mesafe hesaplayıcı

Bu snippet'i iki giriş arasındaki mesafeyi hesaplamak için kullanabilirsiniz:

function L(s,t){if(s===t)return 0;var S=s.length,T=t.length;if(S*T===0)return S+T;for(var i=0,v0=[],v1=[];i<=T;i++)v0[i]=i;for(i=0;i<S;i++){v1[0]=i+1;for(var j=0;j<T;j++)v1[j+1]=Math.min(v1[j]+1,v0[j+1]+1,v0[j]+(s[i]!=t[j]));for(j=0;j<=T;j++)v0[j]=v1[j]}return v1[T]}

<textarea id=A rows=10></textarea><textarea id=B rows=10></textarea><br>
Distance: <span id=O>0</span> <button onclick="O.innerHTML=L(A.value.replace(/\s/g,''),B.value.replace(/\s/g,''))">Run</button>

Cevap 20, Brain-Flak , 11

Ben sadece bu hedefe katkıda bulunan herkese teşekkür etmek istiyorum:

• Riley, 20 bayt

• LegionMammal, 15 bayt

• ETHproductions, 11 bayt

• Lynn, 1 bayt

Aşağıdaki kullanıcılar baytlara doğrudan katkıda bulunamadılar, ancak başka şekillerde yardımcı oldular:

• Mistah Figgins

• DJMcMayhem

• feersum

Bunu mümkün kıldığınız için herkese teşekkürler!

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw
)((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}
#R
{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

Çevrimiçi deneyin!

Cevap 3: MATL, Mesafe 15

:tGw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)

Cevap 7, Japt, 15

ò f!vU"Gw\((()<>))
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)#Rḍ⁸T”

Çevrimiçi deneyin!

Değiştirildi #b∫I:b;\?tiçin ò f!vU(10 puan) ve değiştirerek biraz daha Beyin Flak kodu ilave ~(()etmek ((()<>))(5 puan). Çalıştığımız kodun

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

açıklama

ò           Generate the range [0...input].
  f         Filter to only items Z where
   !vU        U.v(Z) returns truthily. (`fvU` would be Z.v(U))
              This returns true if U is divisible by Z, false otherwise.
      "...  The rest of the program is enclosed in this string, which is passed as an extra
            argument to `f`. Fortunately, `f` ignores it.
            Implicit: output result of last expression

Yanıt 8, 05AB1E , 14

"'ò f!vUGw\((()<>)){((({'
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)
'#Rḍ⁸T”'".e

Çevrimiçi deneyin!

açıklama

Neyse ki 05AB1E'de yerleşik bir Python yorumlayıcısı vardır. Bu koşuyu gerçekleştirmek için

'ò f!vUGw\((()<>)){((({'
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)
'#Rḍ⁸T”'

yığının en üstüne bir dize olarak. Burada yorumlar yerine dize değişmez değerleri kullanmalıyız çünkü 05AB1E Python kodundaki yorumları gerçekten sevmiyor. Ayrıca "orijinal kodda kurtulmak zorundayız, çünkü dizenin erken bitmesine neden olur.

Dize itildikten sonra .epython kodu olarak yürütmek için kullanırız .

Brain-Flak yönünde çalışma

Brain-Flak yanıtı vermek için 5 karakter daha ekleyebildim. 6 eklemek mümkün olurdu ama ne yazık ki beyaz boşluk puan puanı sayılmaz unuttum.

Şimdiye kadar:

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

Cevap 13, Pyth , 15

f!%QTS|Q"@░┼_¥
f!vUGw((({})<>)){((({}[()]n=int(input({})(<>))i=1div=while((<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.eX
╜R;`;╜%Y*`M∩

Çevrimiçi deneyin!

açıklama

Bu yüzden çok fazla Pyth bilmiyorum, ama bildiğim kaynak kodun bir ağaç şeklinde olması, her komutun sağında belirli sayıda argüman alması. Yazdığım bölen programının ağacı şöyle:

     f
    / \
   !   S
   |   |
   %   Q
  / \
 Q   T

Qgirdidir. fiki bağımsız değişkeni alır, Fve A, ve iadeler ürün Tiçinde Anerede F(T)bir truthy değeri döndürür. Bu durumda, FDEĞİL mantıksal döndüren bir fonksiyondur Q%Tve Abir SQdizi yaratan, [1...Q]. Bu, yalnızca tamsayılar için filtreleme etkisi vardır Tiçinde [1...Q]nerede Q%T == 0.

Kodun geri kalanını ayrıştırmaktan kaçınmak için, her şey bir dizeye sarılır, daha sonra |Q"...mantıksal OR Qveya dizesini döndürür. QHer zaman pozitif olduğundan , her zaman doğrudur ve bu nedenle her zaman mantıksal OR'den döndürülür.

Brain-Flak yönünde çalışma

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

Yanıt 16, GolfScript, 15

~:
),(;{
\%!},p#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}<>)){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

Çevrimiçi deneyin!

~:␤),(;{␤\%!},p#Newline'ı boyut kısıtlamasına uyacak şekilde değişken bir ad olarak kullanarak ekledim ve yorum yapmak için tüm programı tek bir satıra sıkıştırdım. Bu mesafe 14'dü. Sonra, Brain-Flak için daha {önce ekledim }printdiv.

~:␤                    Read input, store as NL
   ),(;                Range [1, 2... NL]
       {␤\%!},         Filter elements that divide NL
              p#       Print and comment everything else out

Brain-Flak yönünde çalışma

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

Cevap 17, CJam , 15

qd:A
),(;
{A\%!},p
e#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{)){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

Çevrimiçi deneyin!

qd:A     # Get input as decimal and store it in A
),(;     # range [0..A]
{    },  # Filter where
 A\%!    # A mod this value == 0
       p # print 
e#...    # comment

Brain-Flak yönünde çalışın (gitmek için 30)

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

Cevap 4 - Jöle , 4

:tGw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)Rḍ⁸T

Çevrimiçi deneyin!

İlgili kod:

Rḍ⁸T

)Bildiğim kadarıyla ayrıştırıcı (inanıyorum) söz konusu olduğunda bağlantıları arasında bir mola gibi davranır.

Yerleşik olacağını ÆDyerine bu bir dizi oluşturur 1ile girişine Rile giriş bölünme için çek, ḍ⁸daha sonra truthy tek merkezli endeksler bir listesini döndürür, T.

Cevap 9, Boşluk, 15

f!vUGw((({})<>)){((({}n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e<SPACES>

Nerede <SPACES>şu dize, yerine T, 0x09 olduğunu Lolduğunu 0x0A ve S0x20 geçerli:

SSSLSLSTLTTTTTSSSLLSSSLSTSSTLSTSSTLTSSTLTSSSLSSSTLTSSSSTSSTLSTSSTLTSTTLTSTLLSLSL
LSSTLSLSTLSTSSSTSTSLTLSSLSLSLLSSSSLLLL

Netlik için yeni satır sonu eklendi. Kuralların yalnızca boşluk olmayan karakterler belirlediğini fark ettim. Hayır, kendime yardım edemedim.

Brain-Flak yönünde çalışma

Daha önce neler olduğu hakkında hiçbir fikrim yok, bu yüzden şimdi:

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

Cevap 18, WSF , 15

q   

































































    d:A(),(;{A\%!},pe#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw)(({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

(Bu, karakter koduyla giriş ve çıkışı alır)

açıklama

WSF, brainfuck'ın olağan operatörler kümesi yerine boşluk kullanması dışında esasen brainfuck'tır. İşte brainfuck'a ayrıştırılan kod:

,
[->+>>>>+<<<<<]>

[
[-<+>>>>+<<<]<[->+<]
>>>>>[-<<+>>]<[->+<]<
[>+>->+<[>]>[<+>-]<<[<]>-]
>>[-]+>[<->[-]]
<
[<<<<.>>>>-]<[->+<]<<<
-
]

Brain-Flak'a doğru ilerleme

WSF yalnızca boşluk olduğu için Brain-Flak koduna 15 karakter daha ekleyebildim. Bu bizi cevaptan 15 km uzağa koyar, bu yüzden yayınlamaktan çekinmeyin.

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

Brain-flak cevabını kendim gönderemeyeceğim için, sadece bu hedefe katkıda bulunan herkese teşekkür etmek için zaman ayıracağımı düşündüm:

• Riley, 16 bayt

• LegionMammal, 15 bayt

• ETHproductions, 11 bayt

• Lynn, 1 bayt

Aşağıdaki kullanıcılar baytlara doğrudan katkıda bulunamadılar, ancak başka şekillerde yardımcı oldular:

• Mistah Figgins

Bunu mümkün kıldığınız için herkese teşekkürler!

Cevap 19, 2 kablo , 15

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>){ifn%i==g00div.append(>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"
ILD¹s%_Ï,

Çevrimiçi deneyin!

Ekstra boşluk kaldırdım, daha önce var olan her şeyi bir dizeye sardım, sonra:

IL        # Push [1 .. input]
  D       # Duplicate
   ¹s%    # For each element: input % element
      _   # Logical not
       Ï  # Keep the values from [1 .. input] where this is 1
        , # print

Cevap 21, Cubix , 15

Sonunda bunu sığdırmayı başardılar :) Neyse ki Brain-Flak cevabı yapıldıktan sonra, çünkü sanırım engellerdim. Uygulamak için tam 15 gerekli.

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw
)(Is{})%?;ONou{((({}[()]<n=int(inpu;<@!-;<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}
#R
{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

Bu, aşağıdaki küple eşleşir

              " q d : A ( )
              , ( ; { A \ %
              ! } , p e # &
              f ! 0 p v ' %
              Q T S | Q @ ░
              ┼ _ ¥ f : : +
              ! v U G w ) (
I s { } ) % ? ; O N o u { ( ( ( { } [ ( ) ] < n = i n t
( i n p u ; < @ ! - ; < > ) ) > < > ) < { i = 1 d i v =
w v h i l e ( ( { } ) ) { ( { } [ ( ) ] ) < > } { } } {
} < > ( [ { } ( ) ] { } ) > < > ) < > { i f n % i = = g
0 0 d i v . a p p e n d ( < { } < > { } < > > i ) i = i
+ 1 } { } p r i n t d i v ) } # R { } T : . e X ╜ R ; j
` ; ╜ 0 % Y * ` M ∩ \ " I L D ¹ s % _ Ï , . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .

Burada deneyebilirsiniz , ancak yapıştırmanız gerekecek. Bazı özellerin kalıcı bağlantı için sorunlara neden olduğundan şüpheleniyorum.

Kod aslında 2 satır üzerindedir. Önemli parçalar:

I s     ) % ? ; O N o u 
        u ; < @ ! - ; 

I s )Bu girdiyi alır, yığının üstünü değiştirir (0 da işe yarardı) ve artışları
% ?Mod ve testi al. 0 ileri doğru devam ederse ya da yönlendirmeye bırakılırsa
; O N oMod sonuçlarını bırakın ve sayıyı bir satırsonu
uU ile aşağıdaki satıra çevirin Aşağıdaki
sırada yürütülür
; - ! @ 10 yığından çıkarın, numarayı girişten çıkarın, test edin ve sıfırsa sonlandırın
< ; uİlk test için hedefi yeniden yönlendirin. Yığının üstünü çıkarın (mod veya çıkarma sonucu) ve artırmak için u geri çevirin

Cevap 6, Python 1.6, 15

#b∫I:b;\?t"Gw\~(()
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)#Rḍ⁸T”

%Sembolleri kaldırdım ve ilk satırı ve son satırın bir kısmını yorumladım. Bu tek başına 15 puanımın 10'u bana mal oldu. Ancak henüz yapılmadı; Python 1 bu olmadığı +=Ben değiştirmek zorunda kaldık i+=1ile i=i+1bana fazladan 3 puan malolan. 2 tane kaldığımdan ((beri başlangıca ekledim . Daha sonra Brain-Flak'a boyun eğmeyi planlıyorum ve ebeveynlere ihtiyacım var.

Cevap 10, Ohm , mesafe 5

@░┼_¥
f!vUGw((({})<>)){((({}n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e<SPACES>

... Whitespace cevabındaki <SPACES>o korkunç ipin yerini aldı .

Biraz arsız bir cevap, çünkü her şey sadece uygulanmayan bir tel.

Cevap 12, Cidden , 15

╩"@░┼_¥
f!vUGw((({})<>)){((({}[()]n=int(input())i=1div=while((<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.e"X
╜R;`;╜%Y*`M∩

Çevrimiçi deneyin!

Aslında cevaptan tek fark, Ciddi bir şekilde, gerçekte kullanılan bir işlevi işaretlemek için backticks kullanması ⌠ve ⌡sadece ekstra karakterleri bir dizeye dönüştürüp pop ve atarız.

Brain-Flak'a Doğru Çalışmak

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

Cevap 14, Del | m | t , 15

                                                f!%QTS|Q"@░┼_¥f!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=while(({})){({}<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.eX╜R;`;╜%Y*`M∩

Çevrimiçi deneyin!

açıklama

Gerçekten, beyaz alanın buradaki farka sayılmadığı gerçeğini kötüye kullanmaya başlıyorum. Del | m | t gerçekten hangi karakterlerle ilgilendiğinizi umursamadığından, kodun büyük çoğunluğu programın başında bir dizi boşluk ve satır başıdır. Kodun gerçek görünür kısımları hiç yürütülmez.

Kod daha "makul" bir şekle dönüştürülür:

O R ^ V O @ A K T A J O @ A K U N R O @ B K U @ A K T Q ^ X @ B K T R ^ P O @ A K T K R ^ _ @ ^ @

Çevrimiçi deneyin!

Düşük seviyede nasıl çalışır

Başlamak için O R ^ V bu ilk döngüde girdi alma hizmetimiz var ve diğer tüm zamanlarda no-op olarak çalışıyor.

Daha sonra Ogirdinin bir kopyasını daha sonra kullanmak üzere kullanırız .

@ A K T-1 bellek konumunda saklanan değişkeni çağırır (programın başında bu 0'dır) ve A Jartırır. O @ A K UŞimdi artan değeri, sonraki döngü için -1 bellek konumuna geri kaydeder.

Nbir süre önce yaptığımız girişin kopya modunu hesaplar ve değer bellekten yeni çağrılır ve Rreddeder.

Birlikte N R, girdimizin Hizmet Koşulları tarafından bölünebilir olup olmadığını gösteren bir boole oluşturun.

Bu boole'nin bir kopyasını kullanarak bellek alanına -2 saklıyoruz O @ B K Uve kullanarak bellek alanından -2 değerini geri çağırıyoruz @ A K T.

Booleanın üstte Qolduğundan emin olmak için üstteki iki öğeyi değiştiririz ve boolean doğru kullanılıyorsa değeri veririz ^ X.

Boolean yanlışsa, ortadan kaldırılması gereken ekstra bir değere sahibiz, böylece boşluk 2'de depoladığımız boolean'ı hatırlar ve @ B K Tyanlışsa bir değer açarız R ^ P.

Girdi değerini ile çoğaltır ve O-1 belleğindeki değeri ile çıkarırız @ A K T K. Eğer bu sıfır ise çıkarız R ^ _.

Son olarak @ ^, bir sonraki değer ne olursa olsun bu atlamalara sahibiz . Buna ihtiyacımız var, çünkü @kodun görünür kısmı tarafından üretilen bir demet önemsiz (aslında sadece bir sembol) var.

Sonuna ulaştığında, başlangıç ​​noktasına geri döner.

Üst düzeyde nasıl çalışır?

Temel fikir, her döngü yaptığımızda artan bellek konumu -1'de saklanan bir değere sahip olduğumuzdur. Eğer bu değer bizim girdimizi bölerse biz onu çıkarırız ve ikisi eşit olduğunda yürütmeyi sonlandırırız.

Brain-Flak'a Doğru İlerleme

Boşluk aradaki farktan sayılmadığından, 15 puanımın herhangi birini harcamadan kodu değiştirebildim ve böylece hepsi Brain-Flak koduna yatırıldı.

İşte mevcut durumumuz.

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

Cevap 15, Befunge-98, 15

&f!0pv
'         %QTS|Q" @ ░┼_¥f
:
:      
+      
!         vUGw(((   {})<>)){((({}[()
]    <    n=int(i   nput({})(<>))><>)
<      {i=1di     v
  =
w    v  
       hile(({      })){({}<>)){ifn%i==
g
0
0    div.app   en   d(i)i=i+1}printdiv)}#R{}T
:      
.    eX╜R;
j      
`      ;╜
0      
%  Y*`M∩
\

Çevrimiçi deneyin!

(Muhtemelen bir sürü gereksiz boşluk var, ama şu anda golf oynamak için rahatsız edemiyorum)

Befunge programı için 15'in hepsini kullandım, bu yüzden Brain-flak'ta bu sefer hiçbir değişiklik yapılmadı.

Bunun için temel stratejim IP'yi dikey olarak göndermek ve önceden varolan koddan belirli karakterleri yürütmek için boşluk kullanmaktı.

Açıklama:

Befunge programı için önemli olan kod şudur:

&f!0pv
'                 @
:
:
+
!
]    <
<                 v
w    v
g
0
0    d
:
.    e
j
`
0
%    `
\

Şuna eşittir:

&f!0pv   Gets input, and stores it at (0, 0) (where the & is)
         The v goes down, hits the < and ], which turns the IP up along the first line

!+::'&   There is a 0 at the bottom of the stack, so ! changes it to a 1 and + increments
         :: duplicates twice, and '& gets the input value

\%       swaps the input and iterator mods them
  0`j.   Checks if input mod iterator is 0 - if it is, print iterator

:00gw    gets the input again, and compares it to the iterator.
         If they are different, the IP travels right to the v
         Otherwise, it continues straight, and hits arrows leading to the end (@)

de`      pushes 0, to be used in the increment line

Cevap 2 - Python 3 , 5

n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i+=1
print(div)

Çevrimiçi deneyin!

Cevap 5 - SOGL 0.8.2 , 9

b∫I:b;\?t"Gw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)Rḍ⁸T”

Açıklama:

b∫              repeat input times                [0]
  I             increment (the loop is 0-based)   [1]
   :b           duplicate                         [1, 1]
     ;          put the input one under the stack [1, 114, 1]
      \?        if divides                        [1, 1]
        t        output                           [1, 1]
         "...”   push that long string            [1, 1, "Gw\~...Rḍ⁸T"]

Not: yorumlayıcının girdi olarak sayılmaması için şu anda \ns ile değiştirilmesi gerekmektedir ¶, ancak ayrıştırıcının kendisi her ikisinin de birbirinin yerine kullanılabileceğini düşünmektedir.

Cevap 11, Aslında , 15

╩@░┼_¥
f!vUGw((({})<>)){((({}]n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e
╜R;⌠;╜%Y*⌡M∩

Çevrimiçi deneyin!

açıklama

Aslında ÷bir sayının faktörlerini bulmak için güzel bir yerleşime sahiptir , ancak bu tür yerleşimleri kullanmamıza izin verilmez.

Girdileri kayıtlara kaydederek başlayacağım, böylece ne olacağı zarar görmeyecek. Bunu kullanarak yapıyorum ╩ama mevcut diğer komutlardan birini kolayca kullanabilirsiniz.

Sonra zaten vardı kodu yapıştırmak (Ben çalışmak için sinir bozucu çünkü tüm boşluk kaldırıldı, çünkü bunu yapabilirsiniz "boşluk sayılmaz"). Neyse ki, yığın boş olduğunda bu çok şey yapmaz.

Sonra programın geri kalanı var

╜   Pull our input from the register
R   Create the range of n
;   Duplicate the range
⌠   Declare a function
 ;  Duplicate n
 ╜  Pull from register
 %  Mod
 Y  Logical not
 *  Multiply by n
⌡   End Function
M   Map the function across the range
∩   Remove the zeros with a Intersection

Brain-Flak'a Doğru Çalışmak

Tüm bu işleri ve ben sadece bir ekstra paren almak mümkün.

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

23, Brain-Flak Klasik, 13

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(Is(({})<>))%?;ONou{((({}[]<n=int(inpu;({})(@!-;<>))><>)<{i=1div=wvhile(({})){({}[])<>}{}}{}<>({<({}[])>[]}[]{}{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

Başlangıçta, @Wheat Wizard beyin-flak-klasik kodunu cevap 22'de olduğu gibi yayınlamıştı:

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

Bu 17 karakter kapalı. Ancak, bunu elde etmek {})için önerilen kodda daha fazla sağa hareket ettirerek bunu sıkıştırabildim

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

Hangi sadece 13 karakter kapalı! Yani tüm yaptığım önerilen kodu almak için parantez eklemek / kaldırmak oldu.

Gönderdiğim orijinal kodun bir yazım hatası vardı, şimdi düzeltildi. ( Teşekkürler @WeatWizard! )

Cevap 1 - Python 2.7

n=input()
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i+=1
print(div)

Mesafe: NA - İlk cevap

Çevrimiçi deneyin!

22, Dil , 15

Lenguage, programın içeriği hakkında ne kadar sürmediğine önem veren bir esolang. Böylece son programı uygun miktarda boşlukla doldurarak istediğimiz dil programını yaratabiliriz. Lenguage brainfuck'a derlendi, bu yüzden bir süre önce yazdığım brainfuck programını tekrar kullanacağız

,[->+>>>>+<<<<<]>[[-<+>>>>+<<<]<[->+<]>>>>>[-<<+>>]<[->+<]<[>+>->+<[>]>[<+>-]<<[<]>-]>>[-]+>[<->[-]]<[<<<<.>>>>-]<[->+<]<<<-]

Daha sonraki cevapları kolaylaştırmak için ana programda birkaç değişiklik yaptım, ancak sonuç şöyle görünüyor:

<SPACES>"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(Is(({})<>))%?;ONou{((({}[()]<n=int(inpu;({})(@!-;<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>({<[{}[]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

burada <SPACES>temsil 55501429195173976989402130752788553046280971902194531020486729504671367937656404963353269263683332162717880399306 uzay karakterler.

Boşluğun kötüye kullanılması kuralı saymıyor mu? Belki.

Brain-Flak Classic için çalışma

Zaten orada o ebeveynlerin hepsine sahiptik, bu yüzden Brain-Flak Classic yolunda bize başlayacağımı düşündüm.

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