Mari kita lihat loop khas, yang biasanya melakukan 8 iterasi:

for (int x=0; x<8; ++x);

Anda harus membuatnya tak terbatas!

Ini adalah kontes popularitas untuk semua bahasa yang mendukung bentuk forloop seperti itu. Jadi solusi dengan skor tertinggi (upvotes minus downvotes) menang.

Jika bahasa Anda memiliki bentuk forlingkaran lain, tetapi Anda yakin, Anda dapat membuat sesuatu yang keren dengan itu, jangan ragu untuk mengirim jawabannya dan menandainya sebagai tidak bersaing. Saya berhak memperbesar ruang lingkup konstruksi dan bahasa yang tersedia, tetapi tidak akan pernah menyusut, jadi jangan takut menjatuhkan solusi yang sebelumnya benar.

Apa solusinya?

Solusi terdiri dari dua program.

Program pertama adalah program bersih . Ini adalah program khas dalam bahasa Anda dengan forloop membuat 8 iterasi. Seharusnya program yang normal, yang bisa ditulis oleh pengembang. Tidak ada peretasan khusus untuk tujuan persiapan. Sebagai contoh:

int main() 
{
  for (int x=0; x<8; ++x);
  return 0;
}

Program kedua ditambah. Program ini harus berisi semua kode dari program bersih dan beberapa kode tambahan. Ada beberapa titik ekstensi, lihat bagian aturan lengkap untuk detailnya. Program augmented untuk yang bersih di atas bisa

inline bool operator < (const int &a, const int &b)
{
  return true;
}

int main() 
{
  for (int x=0; x<8; ++x);
  return 0;
}

Itu hanya sebuah contoh (tidak dapat dikompilasi dalam C ++) untuk menunjukkan ide. Program augmented benar benar harus dapat dikompilasi, bekerja dan memiliki loop tak terbatas.

Aturan lengkap

Kedua program:

• Bahasa apa pun dengan dukungan forloop seperti itu ok.
• Badan loop harus kosong. Lebih tepatnya, Anda dapat menempatkan beberapa output atau kode lain ke dalam loop, tetapi perilaku loop harus sama jika loop kosong.

Program bersih:

• Loop menggunakan bilangan bulat atau numerik dan melakukan 8 iterasi:

  for (int          x=0; x<8; ++x);   // C, C++, C#
  for (var          x=0; x<8; ++x);   // C#, Javascript
  for (auto         x=0; x<8; ++x);   // C, C++
  for (auto signed  x=0; x<8; ++x);   // C, C++
  for (register int x=0; x<8; ++x);   // C, C++
  

• Jenis yang ditentukan pengguna tidak diizinkan.

• Penggunaan properti (kecuali variabel global) sebagai ganti variabel loop tidak diizinkan.

• Deklarasi variabel bisa di dalam atau di luar loop. Kode berikut ok:

  int x;
  for(x=0; x<8; ++x);
  

• Baik kenaikan awalan atau postfix dapat digunakan.

• Batas lingkaran 8harus ditulis sebagai literal konstan tanpa menyimpan ke konstanta bernama atau variabel. Itu dibuat untuk mencegah solusi berdasarkan mendeklarasikan variabel atau konstanta sama dengan 8, dan kemudian menugaskan kembali, menimpa atau membayangi dengan nilai lain:

  const double n = 8;
  
  int main()
  {
    const double n = 9007199254740992;
    for (double x=0; x<n; ++x);
    return 0;
  }
  

Program augmented:

• Harus mengandung semua kode dari kode yang bersih.
• Harus memperluas program bersih dalam jumlah terbatas poin ekstensi.
• Harus mengeksekusi loop yang sama for dengan infinite loop itu sendiri.
  Menempatkan loop ke dalam konstruksi tak terbatas lain tidak ok.
• Runtime atau kompilasi waktu tambalan kode diizinkan selama representasi tekstual tidak berubah.
• Menempatkan konstruksi ke dalam string dan meneruskannya evaltidak diizinkan.

Poin ekstensi:

• Di mana saja di luar fragmen dengan kode bersih, termasuk file lain atau rakitan lainnya.
• forpernyataan (sebagai bagian tunggal - forkonstruksi dan tubuhnya) harus dijaga tidak berubah.
• Deklarasi variabel harus tetap sama.
• Setiap tempat di antara pernyataan sederhana dapat digunakan sebagai titik ekstensi.
• Jika dan hanya jika variabel dinyatakan di luar loop dan tanpa penugasan langsung dari nilai, penugasan tersebut dapat ditambahkan.

/* extension point here */
int main()
/* extension point here */
{
  /* extension point here */
  int x /* extension point for assignment here */;
  /* extension point here */
  for (x=0; x<8; ++x);
  /* extension point here */
  return 0;
  /* extension point here */
}
/* extension point here */

int main() 
{
  /* BEGIN: No changes allowed */ int x = 0; /* END */
  /* extension point here */
  /* BEGIN: No changes allowed */ for (x=0; x<8; ++x); /* END */
  return 0;
}

PS: Jika memungkinkan, berikan tautan ke IDE online.

Python3

Program Bersih:

Ini hanya hitungan mundur standar saat loop.

n = 8
while n != 0:
  n -= 1
print("done")

Program Augmented:

import ctypes

ctypes.cast(id(8), ctypes.POINTER(ctypes.c_int))[6] = 9

n = 8
while n != 0:
  n -= 1
print("done")

Ia menggunakan int cache mendefinisikan kembali 8sebagai 9yang secara efektif membuat n -= 1no-op, karena 9-1 = 8yang hanya menetapkan nkembali ke 9lagi, menyebabkan loop tak terbatas.

Anda dapat melihat cache int beraksi online di sini (meskipun jelas tanpa loop tanpa batas karena online).

Python 3

Program Bersih:

Cara standar untuk melakukan sesuatu 8 kali dalam python adalah:

for i in range(8): 
    # Do something
    pass

Program Augmented:

Namun, jika kita mengesampingkan fungsi rentang generator untuk menghasilkan 1, itu menjadi loop tak terbatas ...

def range(x):
    while 1: yield 1

for i in range(8):
    # Infinite loop
    pass

Kita dapat mengambil ini lebih jauh dan membuat fungsi generator yang, bukannya menghasilkan 1, menghitung selamanya:

def range(x):
    i = 0
    while 1: yield i; i+=1

for i in range(8):
    # Counting from 0 to infinity
    pass

Uji pada repl.it

Perl

Bersih

for($i=0; $i<8; $i++) { }

Diperbesar

*i=*|;
for($i=0; $i<8; $i++) { }

Ideone .

ES5 + (Javascript)

EDIT : Dihapus deklarasi variabel eksplisit, karena jika tidak diangkat dan properti window.x tidak dapat dikonfigurasi dibuat (kecuali dijalankan baris demi baris di konsol REPL).

Penjelasan:

Manfaatkan fakta bahwa setiap variabel yang dicakup secara global juga merupakan properti dari objek jendela , dan mendefinisikan ulang properti "window.x" untuk memiliki nilai konstan 1.

Bersih

for(x=0; x<8; x+=1) console.log(x);

Diperbesar

Object.defineProperty(window,'x',{value:1});
for(x=0; x<8; x+=1) console.log(x);

CATATAN : Untuk membuat ini berfungsi di Node.js, cukup ganti "window" dengan "global" (diuji dalam Node.js 6.8.0)

C

Program bersih

int main() 
{
  for (int x=0; x<8; ++x);
  return 0;
}

Program augmented

#define for(ever) while(1)

int main() 
{
  for (int x=0; x<8; ++x);
  return 0;
}

Jawa

Program bersih:

public class Main {
    public static void main(String[] args) throws Exception {
        for (Integer i = 0; i < 8; i++);
    }
}

Program augmented:

import java.lang.reflect.Field;

public class Main {
    public static void main(String[] args) throws Exception {
        Class cache = Integer.class.getDeclaredClasses()[0];
        Field c = cache.getDeclaredField("cache");
        c.setAccessible(true);
        Integer[] intcache = (Integer[]) c.get(cache);
        intcache[129] = intcache[128];

        for (Integer i = 0; i < 8; i++);
    }
}

Menyetel Integer dalam cache Integer yang harus berisi 1 hingga 0, secara efektif i++tidak melakukan apa-apa (seti ke Integer yang di-cache yang seharusnya berisi 1, tetapi karena Integer itu benar-benar berisi 0, tidak ada perubahan).

C ++

int main() 
{
#define int bool
  for (int x=0; x<8; ++x);
  return 0;
}

boolhanya bisa 0 atau 1. Terinspirasi oleh jawaban Perl primo .

Python 3 (3.5.0)

Program Bersih:

for i in range(8):
    print(i)

Diperbesar

import sys

from ctypes import *

code = sys._getframe().f_code.co_code

cast(sys._getframe().f_code.co_code, POINTER(c_char*len(code))).contents[len(code)-4] = 113
cast(sys._getframe().f_code.co_code, POINTER(c_char*len(code))).contents[len(code)-3] = 160

for i in range(8):
    print(i)

Solusi ini tidak seperti yang lain yang ditulis dalam Python dalam hal itu benar-benar mengubah kode sumber dengan cepat. Semua hal dalam for loop dapat diubah menjadi kode apa pun yang diinginkan.

Kode mengubah opcode kedua menjadi terakhir menjadi 113atau lebih mudah dibaca -JUMP_ABSOLUTE . Ini mengubah operan ke 160- instruksi di mana for loop dimulai, yang pada dasarnya menciptakan pernyataan GOTO di akhir program.

Program yang diperbesar mencetak angka-angka 0..7tanpa batas berkali-kali tanpa tumpukan-tumpah atau serupa.

PHP

Saya pikir ini mengikuti aturan titik perpanjangan; Saya tidak sepenuhnya jelas pada poin 4. Ini sangat mirip dengan jawaban perl @ primo jadi saya pikir itu penting.

Bersih

for(;$i<8;$i++);

Diperbesar

$i='a';
for(;$i<8;$i++);

PHP memungkinkan Anda menambahkan string tertentu, seperti:

'a' -> 'b'
'b' -> 'c'
'z' -> 'aa'
'aa' -> 'ab'
'aab' -> 'aac'
etc

Semua string ini bernilai 0, jadi ini akan berulang secara praktis selamanya (kecuali kehabisan memori).

Perl

Kode bersih

for ($x = 0; $x < 8; $x++) {}

Kode augmented

sub TIESCALAR {bless []}
sub FETCH {}
sub STORE {}
tie $x, "";

for ($x = 0; $x < 8; $x++) {}

Kebanyakan variabel Perl hanyalah variabel. Namun, bahasa ini juga memiliki tiefitur, yang memungkinkan Anda untuk secara efektif memberikan variabel getter dan setter. Dalam program ini, saya membuat paket utama (yang namanya adalah string nol) menjadi setara dengan kelas dari bahasa berorientasi objek, sementara juga menjadikannya sebuah program. Itu memungkinkan saya untuk mengikat forloop counter ke program itu sendiri. Implementing TIESCALARmemungkinkan tidak berpengaruh, dan upaya untuk membacanya selalu kembali , yang jumlahnya kurang dari 8.tie untuk berhasil; nilai pengembalian TIESCALARdimaksudkan untuk menjadi referensi ke keadaan internal apa pun yang perlu kita pertahankan terkait dengan variabel, tetapi karena kita tidak memerlukannya, kita mengembalikan referensi array kosong sebagai pengganti. Kami kemudian memberikan implementasi yang paling sederhana dari pengambil dan penyetel; tak satu pun dari mereka melakukan apa pun, jadi upaya untuk menetapkan$xundef

WinDbg

Bersih

.for (r$t0 = 0; @$t0 < 8; r$t0 = @$t0 + 1) { }

Diperbesar

aS < |;                                            * Create alias of < as |
.block {                                           * Explicit block so aliases are expanded
    .for (r$t0 = 0; @$t0 < 8; r$t0 = @$t0 + 1) { } * Condition is now @$t0 | 8, always true
}

Pendekatan ini menciptakan alias untuk <as |, jadi ketika <ditemui dalam kode alias diperluas ke |dan bitwise-atau dilakukan bukannya kurang dari. Di WinDbg semua nilai bukan nol anything | 8adalah benar sehingga selalu benar.

Catatan: Ini .blocktidak benar-benar diperlukan jika aSdan .forbenar-benar dimasukkan sebagai dua baris berbeda seperti yang ditunjukkan di sini, itu hanya diperlukan ketika aSdan .forberada di baris yang sama.

Mathematica

Bersih

For[x = 0, x < 8, ++x,]

Diperbesar

x /: (x = 0) := x = -Infinity;
For[x = 0, x < 8, ++x,]

Gangguan umum

Kode bersih

(dotimes(i 8))

Diperbesar

(shadowing-import(defmacro :dotimes(&rest args)'(loop)))
(dotimes(i 8))

Makro bernama keyword:dotimes, alias :dotimes(lihat 11.1.2.3 Paket KEYWORD ) didefinisikan yang mengembang sebagai loop tak terbatas. The defmacropengembalian makro nama makro yang ditetapkan, yang dapat diumpankan ke shadowing-import. Jadi, ini barudotimes simbol simbol membayangi simbol standar (yang tidak boleh didefinisikan ulang atau secara leksikal terikat dengan makro lain dalam program portabel).

Bertambah (2)

(set-macro-character #\8 (lambda (&rest args) '(loop)))
(dotimes(i 8))

Ketika kita membaca karakter 8, kita menggantinya dengan (loop). Itu berarti bahwa di atas dibaca sebagai (dotimes (i (loop)))dan kode tidak pernah berhenti menghitung batas atas. Ini berdampak pada semua kejadian 8, tidak hanya yang ada di loop. Dengan kata lain, 8 adalah singkatan dari infinity. Jika Anda penasaran, ketika tabel dibaca diubah seperti di atas, maka karakter 8 menjadi "terminating", dan melepaskan diri dari angka / simbol lain yang sedang dibaca:

(list 6789)

... dibaca sebagai:

(list 67 (loop) 9)

Anda dapat menjalankan tes di Ideone: https://ideone.com/sR3AiU .

Rubi

Bersih

Semacam ini untuk loop tidak banyak digunakan di Ruby, tetapi tutorial khas akan memberi tahu Anda bahwa ini adalah cara untuk melakukannya:

for x in 1..8
  # Some code here
end

Diperbesar

Untuk loop hanya memanggil (1..8).eachdengan blok kode yang diberikan, jadi kami mengubah metode itu:

class Range
  def each
    i = first
    loop { yield i; i+= 1 }
  end
end

for x in 1..8
  # Some code here
end

Haskell

Versi bersih:

import Control.Monad (forM_)

main = forM_ [0..8] $ \i -> print i

Versi augmented:

import Control.Monad (forM_)

data T = C

instance Num T where
    fromInteger _ = C

instance Enum T where
    enumFromTo _ _ = repeat C

instance Show T where
    show _ = "0"

default (T)

main = forM_ [0..8] $ \i -> print i

Ini cukup mendasar, sungguh: kita hanya mendefinisikan tipe kita sendiri Tsehingga enumFromToinstansnya adalah urutan yang tak terbatas, kemudian gunakan jenis defaulting sehingga nilai-nilai yang tidak di-anotasi 0dan 8diambil sebagai tipe T.

///

Tidak ada yang eksplisit for loop di ///, tetapi dapat disimulasikan (setelah semua selesai).

Bersih:

/1/0/
/2/1/
/3/2/
/4/3/
/5/4/
/6/5/
/7/6/
/8/7/
8

Diperbesar:

/0/0/
/1/0/
/2/1/
/3/2/
/4/3/
/5/4/
/6/5/
/7/6/
/8/7/
8

Apa yang sedang terjadi?

Sementara mantan Program menghitung mundur 8-0, yang terakhir itu /0/0/aturan akan menggantikan 0oleh 0sampai kekekalan.

Javascript ES6

OK, inilah versi yang berfungsi menggunakan ES6 untuk ... dari konstruk loop. Saya bahkan akan memberi Anda array yang bersih sehingga kami yakin tidak ada bisnis yang lucu:

Bersih

for(a of [0,1,2,3,4,5,6,7]);

Tentu saja, itu tidak menghentikan seseorang dari mengacaukan prototipe Array ...

Diperbesar

Array.prototype[Symbol.iterator]=function(){return {next: function(){return {done: false}}}}
for(a of [0,1,2,3,4,5,6,7]);

Ini berfungsi dengan menulis-ulang iterator default sehingga tidak pernah berakhir, oleh karena itu mengunci semuanya menjadi loop tak terbatas. Kode bahkan tidak memiliki kesempatan untuk menjalankan hal-hal di dalam loop.

C ++

Menggunakan 2 titik ekstensi:

struct True {
  True(int x){}
  bool operator<(const int&){
    return true;
  }
  void operator++(){}
};


int main() 
{
#define int True
  for (int x=0; x<8; ++x);
  return 0;
}

Program bersih sama seperti dalam deskripsi.

Brainfuck

Saya mencetak '0' setiap iterasi, hanya untuk memudahkan penghitungan iterasi. Tetapi kode apa pun bisa dimasukkan di sana tanpa mengubah cara kerja loop.

Bersih

>> ++++++ [-<++++++++>] <<                   b = '0' (value to be printed each iteration)

>> ++++++++ [-<< ++++++++ ++++++++ >>] <<    for (a = a plus 128;
[                                              a;
++++++++ ++++++++                              a = a plus 16 (mod 256)) {
>.<                                              loop body (print b)
]                                            }

Cobalah online

Versi augmented bergantung pada implementasi Brainfuck yang umum dengan sel 8 bit. Pada implementasi ini, "increment" sebenarnya "increment (mod 256)". Dengan demikian untuk menemukan loop yang akan mengulangi persis 8 kali dalam versi bersih dan tanpa akhir dalam versi augmented, kita dapat dengan mudah menemukan solusi untuk sistem ketidaksetaraan berikut.

• a + b * 8 (mod 256) == 0 (untuk versi bersih)
• c + a + b * n (mod 256)> 0 untuk semua n (untuk versi augmented)
• a> 0

Dalam kasus ini, kita membiarkan a = 128, b = 16, dan c = 1. Jelas 128 + 16 * 8 = 256 (dan 256 (mod 256) = 0) dan 128> 0, dan karena b adalah genap, c + a + b * n ganjil untuk a + c aneh, dan dengan demikian tidak akan pernah ada kelipatan 256 dari kasus-kasus seperti itu. Kami memilih c = 1 demi kesederhanaan. Jadi satu-satunya perubahan yang kita butuhkan adalah satu+ di awal program.

Diperbesar

+                                            increment a (only change)
>> ++++++ [-<++++++++>] <<                   b = '0' (value to be printed each iteration)

>> ++++++++ [-<< ++++++++ ++++++++ >>] <<    for (a = a plus 128;
[                                              a;
++++++++ ++++++++                              a = a plus 16 (mod 256)) {
>.<                                              loop body (print b)
]                                            }

Cobalah online

Saya serahkan pada OP untuk menentukan apakah entri ini bersaing. Brainfuck tidak memiliki perulangan eksplisit, tetapi bentuk perulangan yang saya gunakan sedekat mungkin. ++++++++juga dekat dengan literal 8yang bisa Anda dapatkan; Saya sudah memasukkan beberapa di antaranya.

Versi bersih hampir pasti merupakan program tipikal yang ditulis dalam bahasa ini, karena Brainfuck Hello World yang terpendek pun diketahui tergantung pada hubungan pengulangan modular untuk bekerja.

Haskell

Bersih

import Control.Monad (forM_)

main = forM_ [0..8] $ \i -> print i

Diperbesar

import Control.Monad (forM_)

import Prelude hiding (($))
import Control.Monad (when)

f $ x = f (\i -> x i >> when (i == 8) (f $ x))

main = forM_ [0..8] $ \i -> print i

Mengganti operator aplikasi fungsi yang biasa $dengan yang mengulang loop lagi setiap kali selesai. Menjalankan versi bersih akan mencetak 0 hingga 8 lalu berhenti; versi yang ditambah mencetak 0 hingga 8 dan kemudian 0 hingga 8 lagi, dan seterusnya.

Saya sedikit curang, karena forM_ [0..8] $ \i -> print iitu belum tentu cara "terbersih" untuk menulis loop itu di Haskell; banyak Haskellers akan mengurangi-loop body untuk mendapatkan forM_ [0..8] printdan kemudian tidak ada $untuk menimpanya. Dalam pembelaan saya, saya menyalin kode bersih dari jawaban Cactus , yang tidak membutuhkan properti itu, jadi setidaknya satu programmer Haskell benar-benar menulis kode itu tanpa motivasi untuk menambahkan kode yang tidak perlu.$ !

C ++

int main() 
{
  int y;
#define int
#define x (y=7)
  for (int x=0; x<8; ++x);
  return 0;
}

Mari kita xevaluasi ke 7. Tidak bekerja di C karena itu membutuhkan nilai lebih pada penugasan dan kenaikan.

Nim

Versi idiomatik, menggunakan countup :

Bersih

for i in countup(1, 8):
  # counting from 1 to 8, inclusive
  discard

Diperbesar

iterator countup(a: int, b: int): int =
  while true:
    yield 8

for i in countup(1, 8):
  # counting 8s forever
  discard

Sederhana, dan sangat mirip dengan jawaban Python yang mengubahrange . Kami mendefinisikan ulang countup, cara Nim idiomatik untuk beralih dari satu int (inklusif) ke int lain, untuk memberikan 8s tanpa batas.

Versi yang lebih menarik, menggunakan operator jangkauan ..:

Bersih

for i in 1..8:
  # counting from 1 to 8, inclusive
  discard

Diperbesar

iterator `..`(a: int, b: int): int =
  while true:
    yield 8

for i in 1..8:
  # counting 8s forever
  discard

Sangat mirip dengan solusi sebelumnya, kecuali kami mendefinisikan ulang operator jangkauan .., yang biasanya akan memberikan array [1, 2, 3, 4, 5, 6, 7, 8], ke iterator dari sebelumnya.

GolfScript

Bersih

0{.8<}{)}while;

Diperbesar

{.)}:8;
0{.8<}{)}while;

Ini menetapkan fungsi mengembalikan n +1 ke variabel 8

tcl

Normal:

for {set i 0} {$i<8} {incr i} {}

Diperbesar:

proc incr x {}
for {set i 0} {$i<8} {incr i} {}

Idenya adalah untuk mendefinisikan kembali incrperintah yang digunakan untuk menambah variabel i, untuk benar-benar tidak menambah!

Dapat diuji di: http://rextester.com/live/QSKZPQ49822

x86_64 Majelis

Program bersih:

mov rcx, 8
loop_start:
sub rcx, 1
cmp rcx,0
jne loop_start
mov rax, 0x01
mov rdi, 0
syscall

Jenis loop yang akan digunakan oleh programmer Majelis, diikuti oleh syscall keluar agar tidak mengaktifkan menambahkan jmp loop_startinstruksi sesudahnya.

Program augmented:

global start
section .text
start:
mov rcx, -1
jmp loop_start
mov rcx, 8
loop_start:
sub rcx, 1
cmp rcx,0
jne loop_start
mov rax, 0x01
mov rdi, 0
syscall

Juga, maaf jika buruk bahwa program bersih tidak memiliki entrypoint atau a section .text

JavaScript

Bersih:

for (var i = 0; !(i > Math.PI * 2.5); i++);

Diperbesar:

window.Math = {PI: NaN};
for (var i = 0; !(i > Math.PI * 2.5); i++);

C ++

Program Bersih

Lingkaran yang bagus dan normal, berputar dari angka 0 hingga 7.

#include <iostream>

int main() {

  for (short i = 0; i < 8; i++) {
    // Print `i` with a newline.
    std::cout << i << std::endl;
  }    

}

Program Augmented

Preprosesor C ++ adalah fitur yang cukup berbahaya ...

#include <iostream>
#define short bool

int main() {

  for (short i = 0; i < 8; i++) {
    // Print `i` with a newline.
    std::cout << i << std::endl;
  }    

}

Satu-satunya baris yang harus kami tambahkan adalah #define short bool . Ini membuat iboolean bukan bilangan bulat pendek, sehingga operator kenaikan ( i++) tidak melakukan apa pun setelah imencapai 1. Output kemudian terlihat seperti ini:

0
1
1
1
1
1
...