Ini jawaban-chaining tantangan secara resmi berakhir, sehingga kemenangan dari Gandum Wisaya , dengan total 7 jawaban. Semua jawaban lain diterima, tetapi tidak akan memengaruhi jawaban yang diterima untuk tantangan ini, maupun pemenangnya.

Tugas:

Cetak semua pembagi positif dari nomor yang xdiambil sebagai input.

Memasukkan:

Satu angka xyang merupakan angka (dalam basis 10) yang pembagi positifnya harus dihitung.

Keluaran:

Semua pembagi positif x. Format diperbolehkan, termasuk \n, ,, ;dan spasi sebagai pemisah, asalkan itu bisa dimengerti. Outputnya juga bisa berupa array Integer atau Strings (misalnya:) [1, 2, 3, 5, 30]. Anda dapat menampilkan pembagi untuk stdout, konsol atau yang setara dalam bahasa Anda atau mereka dapat dikembalikan dari suatu fungsi .

Aturan

• Seorang pengguna tidak boleh menjawab dua kali berturut-turut
• Jawaban Anda dapat menghapus, menambah atau mengganti paling banyak 15 karakter dari jawaban sebelumnya (spasi tidak dihitung), selain untuk Jawaban 2 yang dapat "mengubah" hingga 20 karakter untuk memulai sesuatu
• Anda tidak diperbolehkan memposting jawaban dalam bahasa pemrograman yang sudah memiliki jawaban, kecuali versi bahasa yang sama sekali berbeda (misalnya: Jika saya mengirim jawaban Python 2.7, Anda dapat mengirimkan jawaban Python 3, tetapi tidak dalam Python 2.6)
• Celah standar tidak diperbolehkan
• Anda tidak diperbolehkan menggunakan built-in untuk mendapatkan pembagi , demi tantangan ini
• Anda harus memasukkan nomor jawaban dan nama bahasa dalam judul pertanyaan dan jumlah karakter yang berubah dari jawaban sebelumnya

Mencetak gol

Pengguna dengan kiriman terbanyak setelah barang diselesaikan menang. Dalam kasus seri, pengguna dengan skor tertinggi pada salah satu jawaban mereka menang. Jika ada skor pada skor juga, maka pengguna dengan pengajuan tertua (jawaban skor tertinggi tertua) akan dinyatakan sebagai pemenang.

Catatan: "menyelesaikan" <=> 7 3 hari telah berlalu sejak jawaban terakhir dikirimkan

Contoh:

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]

Atau output setara lainnya yang memenuhi kondisi yang disebutkan.

Catatan Akhir : Pertanyaan ini lebih baik jika Anda mengurutkan jawaban berdasarkan yang terlama. Saya akan memposting jawaban pertama dengan Python 2.7, jadi Anda harus memposting jawaban kedua tergantung pada yang itu. Semoga berhasil dan selamat bersenang - senang!

Papan peringkat:

Daftar ini mungkin kedaluwarsa, bebas diedit:

1) Wheat Wizard [Pemimpin Sekarang 🏆] : 7 jawaban - Python 1.6 , 05AB1E , Sebenarnya , Del | m | t , WSF , Brain-Flak , Bahasa

2) Riley: 3 jawaban - Serius , CJam , 2sable

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

3) ETHproduksi: 2 jawaban - Japt , Pyth

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

6) Riker: 1 jawaban - MATL

6) dzaima: 1 jawaban - SOGL 0.8.2

6) LegionMammal978: 1 jawaban - Whitespace

6) Nick Clifford: 1 jawaban - Ohm

6) Lynn: 1 jawaban - GolfScript

6) MickyT: 1 jawaban - Cubix

Kalkulator jarak

Anda dapat menggunakan potongan ini untuk menghitung jarak antara dua entri:

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>

Jawaban 20, Brain-Flak , 11

Saya ingin meluangkan waktu untuk mengucapkan terima kasih kepada semua orang yang telah membantu berkontribusi untuk tujuan ini:

• Riley, 20 byte

• LegionMammal, 15 byte

• ETHproduksi, 11 byte

• Lynn, 1 byte

Pengguna berikut tidak dapat berkontribusi byte secara langsung tetapi memang membantu dengan cara lain:

• Figah Mistah

• DJMcMayhem

• feersum

Terima kasih semuanya telah memungkinkan ini!

"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%_Ï,

Cobalah online!

Jawaban 3: MATL, Jarak 15

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

Jawaban 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”

Cobalah online!

Diubah #b∫I:b;\?tmenjadiò f!vU (10 poin) dan menambahkan beberapa kode Brain-Flak dengan mengubah ~(()ke ((()<>))(5 poin). Saya percaya kode yang sedang kami kerjakan adalah

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

Penjelasan

ò           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

Jawaban 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

Cobalah online!

Penjelasan

Untungnya 05AB1E memiliki interpreter Python bawaan. Untuk menjalankan ini, kami mendorong

'ò 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”'

sebagai string ke atas tumpukan. Kita harus menggunakan string literal alih-alih komentar di sini karena 05AB1E benar-benar tidak suka komentar dalam kode Python-nya. Kita juga harus menyingkirkan "kode asli karena menyebabkan string berakhir sebelum waktunya.

Setelah string ditekan, kita gunakan .euntuk mengeksekusinya sebagai kode python.

Bekerja menuju Brain-Flak

Saya dapat menambahkan 5 karakter tambahan untuk tujuan membuat jawaban Brain-Flak. Saya akan bisa menambahkan 6 tetapi sayangnya saya lupa spasi tidak dihitung menuju skor poin.

Sejauh ini kami memiliki:

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

Jawaban 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∩

Cobalah online!

Penjelasan

Jadi saya tidak tahu banyak Pyth, tetapi yang saya tahu adalah bahwa kode sumbernya dalam bentuk pohon, setiap perintah mengambil sejumlah argumen di sebelah kanannya. Pohon program pembagi yang saya tulis terlihat seperti ini:

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

Qadalah input. fmengambil dua argumen, Fdan A, dan mengembalikan item Tdi Amana F(T)mengembalikan nilai yang sebenarnya. Dalam hal ini, Fadalah fungsi yang mengembalikan logika NOT dari Q%T, dan Aadalah SQ, yang menciptakan rentang [1...Q]. Ini memiliki efek penyaringan hanya bilangan bulat Tdi [1...Q]mana Q%T == 0.

Untuk menghindari parsing sisa kode, semuanya dibungkus dalam string, kemudian |Q"...mengembalikan OR logis Qdan string. Karena Qselalu positif, selalu benar, dan dengan demikian selalu dikembalikan dari OR logis.

Bekerja menuju Brain-Flak

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

Jawaban 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∩\

Cobalah online!

Saya menambahkan ~:␤),(;{␤\%!},p#, menggunakan baris baru sebagai nama variabel agar sesuai dengan batasan ukuran, dan memadatkan seluruh program kembali ke satu baris untuk berkomentar. Ini jarak 14. Kemudian, saya menambahkan {sebelumnya }printdivuntuk Brain-Flak.

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

Bekerja menuju Brain-Flak

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

Jawaban 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∩\

Cobalah online!

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

Bekerja menuju Brain-Flak (30 pergi)

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

Jawaban 4 - Jelly , 4

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

Cobalah online!

Kode yang relevan:

Rḍ⁸T

The )bertindak sebagai istirahat antara link sejauh parser yang bersangkutan (saya percaya).

Built-in akan ÆD, sebagai gantinya ini menciptakan rentang dari 1ke input dengan R, memeriksa keterpisahan dengan input dengan ḍ⁸, kemudian mengembalikan daftar indeks berbasis satu yang benar dengan T.

Jawaban 9, Ruang Putih, 15

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

Di mana <SPACES>diganti oleh string berikut, di mana T0x09, Ladalah 0x0A, dan S0x20:

SSSLSLSTLTTTTTSSSLLSSSLSTSSTLSTSSTLTSSTLTSSSLSSSTLTSSSSTSSTLSTSSTLTSTTLTSTLLSLSL
LSSTLSLSTLSTSSSTSTSLTLSSLSLSLLSSSSLLLL

Baris baru literal ditambahkan untuk kejelasan. Memperhatikan bahwa aturan hanya menentukan karakter non-spasi putih. Tidak, tidak bisa menahan diri.

Bekerja menuju Brain-Flak

Saya tidak tahu apa yang terjadi sebelumnya, jadi sekarang kami memiliki:

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

Jawaban 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∩\

(Ini membutuhkan input dan output melalui kode karakter)

Penjelasan

WSF pada dasarnya adalah brainfuck kecuali ia menggunakan spasi alih-alih set operator yang biasa. Berikut adalah kode yang didekompilasi menjadi brainfuck:

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

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

Kemajuan menuju Brain-Flak

Karena WSF hanyalah spasi putih, saya dapat menambahkan 15 karakter lagi ke kode Brain-Flak. Ini membuat kami berada pada 15 dari jawaban, jadi jangan ragu untuk mempostingnya.

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

Karena saya tidak akan memposting jawaban Brain-flak sendiri, saya pikir saya akan meluangkan waktu untuk berterima kasih kepada semua orang yang telah membantu berkontribusi untuk tujuan ini:

• Riley, 16 byte

• LegionMammal, 15 byte

• ETHproduksi, 11 byte

• Lynn, 1 byte

Pengguna berikut tidak dapat berkontribusi byte secara langsung tetapi memang membantu dengan cara lain:

• Figah Mistah

Terima kasih semuanya telah memungkinkan ini!

Jawaban 19, 2sable , 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%_Ï,

Cobalah online!

Saya menghapus spasi putih, membungkus semua yang ada sebelumnya menjadi string, lalu:

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

Jawaban 21, Cubix , 15

Akhirnya berhasil masuk ini :) Untungnya setelah jawaban Brain-Flak selesai, karena saya pikir saya akan terhalang. Membutuhkan 15 penuh untuk diimplementasikan.

"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%_Ï,

Ini memetakan ke kubus berikut

              " 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 % _ Ï , . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .

Kamu bisa mencobanya di sini , tetapi Anda harus menempelkannya. Saya menduga beberapa spesial menyebabkan masalah untuk permalink.

Kode ini pada dasarnya lebih dari 2 baris. Bagian penting adalah:

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

I s )Ini mendapat input, menukar bagian atas tumpukan (0 akan bekerja juga) dan peningkatan
% ?Dapatkan mod dan uji. Jika 0 carry forward atau drop down ke redirect
; O N oJatuhkan hasil mod dan output nomor yang diikuti dengan baris baru
uU berbelok ke garis bawah
Berikut adalah dalam rangka dieksekusi
; - ! @ Keluarkan 10 dari stack, jumlah kurangi dari input, tes dan mengakhiri jika nol
< ; uArahkan target untuk tes pertama. Buang bagian atas tumpukan (baik hasil mod atau kurangi) dan putar balik kembali ke kenaikan

Jawaban 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”

Saya menghapus %simbol dan mengomentari baris pertama dan sedikit dari baris terakhir. Ini saja menghabiskan 10 dari 15 poin saya. Namun saya belum selesai; karena Python 1 tidak harus +=saya ganti i+=1dengan i=i+1biaya tambahan 3 poin. Karena saya memiliki 2 sisa, saya juga menambahkan ((ke awal. Saya berencana untuk membuat pengajuan di Brain-Flak nanti dan saya perlu orangtua.

Jawaban 10, Ohm , jarak 5

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

... di mana <SPACES>digantikan oleh string mengerikan dari jawaban Whitespace .

Sedikit jawaban yang kurang ajar, karena yang lainnya hanyalah kawat yang tidak dieksekusi.

Jawaban 12, Serius , 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∩

Cobalah online!

Satu-satunya perbedaan dari jawaban Actually adalah bahwa Serius menggunakan backticks untuk menandai fungsi di mana Actually menggunakan ⌠dan ⌡dan kami hanya membuat karakter tambahan menjadi string kemudian muncul dan buang.

Bekerja Menuju Brain-Flak

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

Jawaban 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∩

Cobalah online!

Penjelasan

Saya benar-benar mulai menyalahgunakan fakta bahwa spasi putih tidak diperhitungkan terhadap perbedaan di sini. Del | m | t tidak terlalu peduli dengan karakter Anda, jadi sebagian besar kode adalah urutan spasi dan carriage return di awal program. Bagian kode yang terlihat tidak dieksekusi sama sekali.

Berikut adalah kode yang ditranskripsi menjadi cara yang lebih "masuk akal":

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 ^ _ @ ^ @

Cobalah online!

Cara kerjanya di level rendah

Untuk memulai kita sudah O R ^ V ini berfungsi untuk mengambil input pada loop pertama dan berfungsi sebagai no-op semua waktu lainnya.

Kami kemudian gunakan Ountuk membuat salinan input untuk nanti.

@ A K Tingat variabel yang disimpan dalam posisi memori -1 (pada awal program ini 0) dan A Jmenambahkannya. O @ A K UMenyimpan nilai yang sekarang bertambah kembali ke posisi memori -1 untuk putaran berikutnya.

Nmenghitung mod dari salinan input yang kami buat beberapa waktu lalu dan nilainya baru diingat dari memori dan Rmeniadakannya.

Bersama-sama N Rmembuat boolean yang menunjukkan apakah input kita dapat dibagi oleh KL atau tidak.

Kami menyimpan salinan boolean ini ke ruang memori -2 menggunakan O @ B K Udan memanggil kembali nilai dari ruang memori -2 @ A K T.

Kami menukar dua elemen teratas dengan Quntuk memastikan bahwa boolean berada di atas dan mengeluarkan nilai jika boolean benar menggunakan ^ X.

Jika boolean itu salah, kita memiliki nilai tambahan yang perlu diberantas jadi kita ingat boolean yang kita simpan di ruang -2 dengan @ B K Tdan pop nilai jika itu salah R ^ P.

Kami menduplikasi nilai input dengan Odan mengurangi nilai pada memori -1 dengan @ A K T K. Jika ini nol, kita keluar R ^ _.

Terakhir kita memiliki @ ^lompatan ini berapa pun nilainya selanjutnya. Kami membutuhkan ini karena ada banyak sampah (sebenarnya hanya satu@ simbol) yang dihasilkan oleh bagian kode yang terlihat.

Setelah mencapai akhir, ia kembali ke awal.

Cara kerjanya di level tinggi

Ide dasarnya adalah bahwa kita memiliki nilai yang terutama disimpan di lokasi memori -1 yang bertambah setiap kali kita mengulang. Jika nilai itu membagi input kita, kita output dan ketika keduanya sama kita mengakhiri eksekusi.

Kemajuan Menuju Flak Otak

Karena spasi tidak dihitung terhadap perbedaan, saya dapat mengubah kode tanpa menghabiskan 15 poin saya dan dengan demikian semuanya diinvestasikan ke dalam kode Brain-Flak.

Ini posisi kami saat ini.

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

Jawaban 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∩
\

Cobalah secara Online!

(Mungkin ada banyak ruang putih yang tidak perlu, tapi saya tidak bisa repot-repot untuk bermain golf sekarang)

Saya menggunakan semua 15 untuk program Befunge, jadi tidak ada perubahan pada Brain-flak kali ini.

Strategi utama saya untuk ini adalah mengirim IP secara vertikal, dan menggunakan spasi untuk mengeksekusi karakter tertentu dari kode yang sudah ada sebelumnya.

Penjelasan:

Kode yang penting untuk program Befunge adalah ini:

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

Yang setara dengan:

&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

Jawaban 2 - Python 3 , 5

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

Cobalah online!

Jawaban 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”

Penjelasan:

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"]

Catatan: penerjemah saat ini perlu \ndiganti dengan ¶agar tidak menghitungnya sebagai input, tetapi parser itu sendiri menganggap keduanya dapat dipertukarkan.

Jawaban 11, Sebenarnya , 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∩

Cobalah online!

Penjelasan

Sebenarnya memiliki builtin yang bagus ÷untuk menemukan faktor-faktor angka, namun kami tidak diizinkan untuk menggunakan builtin tersebut.

Saya mulai dengan menyimpan input ke register sehingga tidak akan terluka oleh apa yang akan terjadi. Saya melakukan ini menggunakan ╩tetapi saya bisa dengan mudah menggunakan salah satu perintah lain yang tersedia.

Lalu saya tempel kode yang sudah kita miliki (saya menghapus semua spasi karena itu mengganggu untuk bekerja dengan, saya bisa melakukan ini karena "spasi tidak dihitung"). Untungnya ini tidak melakukan apa-apa saat tumpukan kosong.

Kemudian kita memiliki sisa program

╜   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

Bekerja Menuju Brain-Flak

Semua itu berhasil dan saya hanya bisa mendapatkan satu paren tambahan.

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

23, Brain-Flak Classic, 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%_Ï,

Awalnya, @Wheat Wizard telah memposting kode brain-flak-classic seperti pada jawaban 22:

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

Ini adalah 17 karakter. Namun, saya dapat memampatkan ini dengan hanya memindahkan {})hak lebih lanjut dalam kode yang diusulkan untuk mendapatkannya

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

Yang hanya 13 karakter! Jadi yang saya lakukan adalah menambah / menghapus tanda kurung untuk mendapatkan kode yang diusulkan.

Kode asli yang saya posting memiliki kesalahan ketik, diperbaiki sekarang. ( Terima kasih @WheatWizard! )

Jawaban 1 - Python 2.7

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

Jarak: NA - Jawaban pertama

Cobalah online!

22, Bahasa , 15

Bahasa adalah esolang yang hanya peduli tentang berapa lama program ini bukan tentang isinya. Jadi kita dapat membuat program bahasa apa pun yang kita inginkan dengan menambahkan program terakhir dengan jumlah spasi yang tepat. Bahasa dikompilasi ke dalam brainfuck jadi kami akan menggunakan kembali program brainfuck yang saya tulis beberapa waktu lalu

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

Saya membuat beberapa perubahan pada program utama untuk memfasilitasi jawaban di kemudian hari, tetapi hasil akhirnya terlihat seperti:

<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%_Ï,

di mana <SPACES>mewakili 55501429195173976989402130752788553046280971902194531020486729504671367937656404963353269263683332162717880399306 karakter ruang.

Apakah saya menyalahgunakan ruang putih tidak termasuk aturan? Mungkin.

Berusahalah menuju Brain-Flak Classic

Kami sudah memiliki semua orangtua itu di sana, jadi saya pikir saya akan memulai kita menuju Brain-Flak Classic.

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