Giriş

Kükreyen 80'leri hatırlıyor musun? Yani, bilirsiniz, 30 yıl önce mi? Cep telefonu yok, internet yok, ATM yok, floresan giysiler (bu neydi ?!) ve kayan çadırlar ! Hayır hayır hayır! Çevrimiçi olanlar değil, gerçek olanlar, LED ışıkları ile.

Nostaljik bir ruh halinde olduğum için, kayan bir seçim çerçevesi oluşturmanızı istiyorum.

Meydan okuma

Tek satırlık bir dize girebileceğiniz bir program oluşturun. Programın gerektiğinde metni tekrarlayarak 80 karakter genişliğinde bir kayan çerçeve oluşturması gerekir.

kurallar

• Kullanıcı, programınıza girdi olarak bir dize girebilmelidir. Dize, bir komut satırı parametresi veya programı çalıştırırken girilen bir dize olabilir.
• Programınız tam olarak 80 (görünür) karakterden oluşan bir dize yazdırmalıdır.
• Dize her 0.1 saniyede bir güncellenmelidir (az ya da çok; zamanlama olmayacağım), karakterleri her yinelemeyi bir konum sola kaydırarak.
• Dize "döner". Kullanıcı tarafından sağlanan dizenin sonunda, dizenin başka bir örneği görünmelidir.
• Programın çıktısını satır beslemeleri olmadan tek bir satıra yazdırmalısınız ('\ n' yerine '\ r' kullanın)
• Programınız , bir kullanıcı araya girene kadar reklam sonsuz çalıştırmalıdır .
• Bu bir codegolf, baytlardaki en kısa kod kazanıyor.
• (Yuvarlak% 10 Bonus yoktur yukarı siyah arka plan üzerinde kırmızı baskı için bir sonraki tam sayıya kadar).
• Standart boşluklar geçerlidir.

Python 2.7'de referans uygulaması

Bu program golf oynamaz, ancak bir referans uygulaması (ve dolayısıyla boyut için bir üst sınır sağlar).

import time,sys
s=raw_input()*99
while 1:
    for i in range(80):
        print s[i:i+80]+'\r',
        sys.stdout.flush()
        time.sleep(0.1)

CJam, 31 bayt

l80*{Dco_80<o(+es99+{es1$<}g;}h

Tam 100 ms bekler.

Çevrimiçi tercüman yalnızca programdan çıktıktan sonra çıktı gösterdiğinden, bu yalnızca resmi Java yorumlayıcısıyla çalışacaktır .

Siyah zemin üzerine kırmızı metin, 36 (veya 39) baytta 36 puan için mümkündür:

0000000: 6c 38 30 2a 7b 22 0d 1b 5b 33 31 3b 34 30 6d 22 6f 5f  l80*{"..[31;40m"o_
0000012: 38 30 3c 6f 28 2b 65 73 39 39 2b 7b 65 73 31 24 3c 7d  80<o(+es99+{es1$<}
0000024: 67 3b 7d 68                                            g;}h

Nasıl çalışır

l80*                             Read a line and repeat it 80 times.
    {                        }h  Do:
     Dco                           Print the character with code point 13.
        _80<o                      Print the first 80 characters of the string.
             (+                    Rotate the string one charcter to the left.
               es99+               Push the current time (ms) plus 99.
                    {     }g       Do:
                     es1$<           Compare the current time with the sum.
                                     Repeat the loop if 99 or less ms have passed.
                            ;      Discard the time stamp.
                                 Repeat the loop.

PowerShell, 11811310110210110 99 96-10%

kod

$s=(Read-Host)*180;for(){Write-Host($s.substring(($i=++$i%80),80)+"`r")-N -F R -B 0;sleep -m 99}

Şimdi ilk döngüye ikinci karakterle başlayan uyarı ile; Kurallar, dizenin önünden başlaması gerektiğini söylemiyor ve ilki genel olarak dahil edildi, bu yüzden benim için iyi. Ben bir şekilde 100 karakter alacak - düzenleme: 100'lerin altına almak için düzenlemeler için teşekkürler @ConnorLSW.

Talimatlar

1. PowerShell'i çalıştırın (normal konsol, PowerShell ISE'de çalışmaz)
2. Tek satırlı sürümü PoSH'ye yapıştırın, enter tuşuna basın
3. Bir mesaj yazın, enter tuşuna basın
4. Kırmak için Ctrl-C

Çıktı

notlar

Değişken adları ve parametreleri biraz doldurulmuş daha okunabilir bir sürüm:

$test = (Read-Host) * 180
for () {
    Write-Host ($text.substring(($i=++$i%80), 80)+"`r") -NoNewLine -ForegroundColor Red -BackgroundColor Black
    sleep -Miliseconds 99
}

• Parametrelerin yalnızca benzersiz olacak kadar uzun olması gerekir, bu nedenle -F Rörneğin bir Red ForegroundColor ayarlamak için yeterince benzersizdir.
• 'Siyah'ın' Mavi 'ile karşılaştırıldığında benzersiz olması için' Bla 'olması gerekir, ancak -B 0Siyah olarak yorumlanan Enum değeri 0 rengine ayarlar.

Alternatif, daha 'doğru' seçim çerçevesi:

Referans kodu, 80 karakterden daha uzun olan dizeleri güzelce işlemez, mesajdaki ~ 160 karakteri geçecek bir şeyi atlar ve her 99 * len (dize) karakterde hata sıfırlar. örneğin işaret genişliği 5 karakter uzunluğundaysa, bunu yapar:

   here is my long test input
 0 |here |            
 1  |ere i|          ^^^^ never shown
 2   |re is|
 3    |e is |
 4     | is m|
 0 |here |
 1  |ere i|
    ...

Bu sürüm, işaret genişliği yerine metin uzunluğunu modüle eder, böylece tüm dizede çalışır. 106-10% = 95 karakter.

$l=($s=Read-Host).Length;for(){Write-Host(($s*160).substring(($i=++$i%$l),80)+"`r")-N -F R -B 0;sleep -m 99}

Alternatif: sorudaki .gif gibi döngülerin işareti,% 118-10 = 106

Çünkü daha iyi görünüyor.

$s=' '*80+(read-host)+' '*80;for(){write-host($s.Substring(($i=++$i%($s.length-80)),80)+"`r")-N -F R -B 0;sleep -m 99}

Matlab, 76 bayt

Burada güzel olduğunu düşündüğüm dizi indeksleri olarak vektörleri olabilir. Bu, karşılık gelen dizi girişlerinin bir vektörünü döndürür, bu da verilen dizeyi uzunluktan bağımsız olarak eklemeyi çok kolay hale getirir.

a=input('');k=1:80;while 1;pause(.1);clc;k=mod(k+1,nnz(a));disp(a(k+1));end

Sonuç:

QBasic, 116 113 bayt -% 10 = 105 102

INPUT s$
COLOR 4
1CLS
FOR i=a TO a+79
?MID$(s$,i MOD LEN(s$)+1,1);
NEXT
?
a=a+1
t=TIMER+.1
2ON(TIMER<t)+2GOTO 2,1

İşte bazı yorumlarla biçimlendirilmiş bir sürüm:

INPUT s$
COLOR 4   ' 4 is the color code for red (the background's already black)

1 CLS   ' CLear Screen (and mark this as line number 1)

' The variable a represents an offset from the beginning of the string
' As a numeric variable, it is 0 at the beginning of the program
FOR i = a TO a + 79
    ' Print i'th character mod string length (+ 1 because QBasic strings
    ' are 1-indexed)
    PRINT MID$(s$, i MOD LEN(s$) + 1, 1);
NEXT i
PRINT
a = a + 1

' Do a busy-wait for .1 seconds
' (Unfortunately, QBasic's SLEEP command only takes integer values)
' Set t to the time we want to stop waiting, .1 seconds in the future
t = TIMER + .1
' We want to stay on line number 2 while TIMER < t; once that condition is
' no longer true, we want to goto the top of the outer loop (line number 1)
' Since true is -1 and false is 0 in QBasic, adding 2 to the conditional
' gives 1 for true and 2 for false; we can pass these values to the
' ON ... GOTO statement to branch conditionally
2 ON (TIMER < t) + 2 GOTO 2, 1

Birkaç not:

• Neden döngüden PRINTsonra FORgerekli olduğunu bilmiyorum .CLSimleci her seferinde sol üst köşeye sıfırlamalıdır. Ama en azından QB64'te, eğer fazladan koymazsam PRINT, seçim çerçevesi birincisi yerine ikinci hatta son bulur. Herhangi biri DosBox veya somesuch üzerinde QBasic kurmuşsa, aynı şeyin orada olup olmadığını veya bir QB64 hatası olup olmadığını bilmek isterim.
• Kodda küçük bir aksaklık vardır, çünkü TIMERgecikmeye dayanır (gece yarısından bu yana geçen saniye sayısı). Kod gece yarısı çalışıyorsa, seçim çerçevesi takılır ve TIMERsıfırlanır 0ve tbundan sonra her zamankinden daha az olur .

Perl, 99 98 bayt (-10% = 89)

$|=@_=split('',pop);printf("\e[31m\r%.80s",join('',@_)x80)while select($a,$a,$a,.1)|push@_,shift@_

Girdisini komut satırı parametresinden alır.

perl marquee.pl "Welcome to Programming Puzzles & Code Golf "

pb , ⌈ (216 + 3) * 0.9⌉ = 198

Tercüman bayrağı için +3 bayt d=1

c^w[Y=-1]{w[B!0]{>}t[X]<[X-79]w[X!0]{t[T-1]w[T=-1]{t[0]}<}vw[T=0]{^w[B!0]{t[B]^b[T]>v}<[X]^w[B!0]{t[B]vw[B!0]{>}b[T]<[X]^w[B=0]{>}b[0]>}v}}^w[1=1]{<[X-80]w[X!0]{<t[B]vb[T]^}w[B!0]{t[B]<b[T]>>}<[X]<t[B]w[B!0]{>}<b[T]}

Oldukça korkunç bir puan, ancak bu dilde herhangi bir şey yapmanın ne kadar zor olduğunu düşünmek daha kötü olabilir. Bu cevabın (kırmızı metin elde etmek için kullanılan bayt) (kırmızı metin elde etmenin bonusu) oranı gerçekten iyidir, tüm çıkış kırmızıya sadece cbaşında gelir!

Her bir işaret arasındaki süre, giriş dizesinin uzunluğuna bağlı olarak değişir, ancak yaklaşık 0.1 saniyedir.

Bu arada, bu programın çıktısı toplam çöp gibi görünüyor çünkü yorumlayıcı çok kötü. Her milisaniyede terminali temizler ve her şeyi yeniden çizer, böylece gerçekten titriyor.

Yorumlarla:

c           # Change paint colour to red

^w[Y=-1]{   # While Y=-1 (arbitrary condition we can break later)

    w[B!0]{>}   # Go to end of input

    t[X]        # Save length of input in T

    # SET T TO MAX(T-79, 0)

    <[X-79]     # Go to (79, -1)

    w[X!0]{     # While X is not 0
        t[T-1]      # Subtract 1 from T
        w[T=-1]{    # If T is now negative
            t[0]        # Set it back to 0
        }
        <         # Move left (position doesn't matter except to end the loop eventually)
    }

    # DONE SETTING T TO MAX(T-79, 0)
    # If T == 0, the string needs to be doubled. Otherwise this part of the program is done

    v           # Move down to break the loop unless this is specifically undone
    w[T=0]{     # While T == 0
        ^w[B!0]{    # For each byte of input
            t[B]^b[T] # Copy it up 1 place
            >v        # Go to the next byte
        }
        <[X]^     # First byte of the copy
        w[B!0]{   # For each byte of the copy
            t[B]      # Save the byte's value
            vw[B!0]{>}# Go to the first empty spot after the original
            b[T]      # Write the saved value
            <[X]^w[B=0]{>} # Go back to the first byte of the copy
            b[0]>     # Erase it and go to the next one
        }
        v       # Back to Y=-1 to reset the loop from the very beginning
    }

}

# After ALL OF THAT nonsense, we're now at (0, 0) and the input string is guaranteed to be
# at least 80 characters long

^
w[1=1]{       # While 1=1 (should hold true until mathematics itself breaks down)
    <[X-80]        # Go to the 81st character
    w[X!0]{        # While X!=0
        <t[B]vb[T]^    # Go left and copy that character down
    }

    w[B!0]{      # For each byte in the string
        t[B]<b[T]>>  # Copy that byte left
    }

    <[X]<t[B]    # Go get the first value (copied to (-1, -1))
    w[B!0]{>}<b[T]# Bring it to the end of the string
}

Perl - 120 bayt (-10% = 108)

$|=1;$_=<>;chomp;for(;;){print "\e[31m",substr(" "x80 .$_,$p++,80)," \r";select($z,$z,$z,0.1);if($p>length()+80){$p=0}}

Matlab, ⌈188 * .9⌉ = 170

Bu, Matlab R2014b veya daha sonraki sürümlerde çalışır. Sonuç bir şekil penceresinde gösterilir.

h=text(.1,.1,repmat(' ',1,80),'fontn','courier','ba','k','co','r');set(1,'pos',[90 90 990 90]);axis off
s=input('','s');n=0;while 1
n=n+1;pause(.1)
h.String=s(mod((0:79)+n,numel(s))+1);end

Aşağıdaki örnekte , daha iyi görselleştirme için metin kalın yazı tipiyle yazılmıştır (yukarıdaki kodda yapılmaz, çünkü birkaç bayta mal olur). GIF animasyonunun hızının gerekli 0,1 saniyelik duraklamaya karşılık gelmediğini, ancak programın çalıştırılmasıyla gösterilen gerçek şekilde zamanlamanın doğru olduğunu unutmayın.

SpecBAS, 130 bayt (-10% = 117)

Orijinal dizeyi 80 veya daha fazla karakter yapmak için çarpar, sonra tam olarak 80'e böler.

TEXTSpecBAS'taki PRINT(bu örnekte) ile aynı şekilde çalışan ancak bir karakteri kaydeden bir komuttur .

SCALEKomut koduna fazladan birkaç karakter ekler, ama daha çadır tarzı bir görünmesini sağlar.

Siz Esc tuşuna basana kadar program devam ediyor.

1 INPUT s$: LET s$=s$*CEIL(80/LEN s$)
2 TEXT PAPER 0;INK 2;SCALE 1,2;AT 1,1;s$( TO 80)
3 LET s$=s$(2 TO)+s$(1): PAUSE 5: GO TO 2

Perl, 63 (70 karakter - bonus için% 10)

Diğerlerine karşı çok farklı bir çözüm değil, ama bunu yapmak için zamanımı boşa harcadım, bu yüzden de göndereceğimi düşündüm!

$_=<>;s/
/ /;print"\x0d\x1b[91m",substr"$_"x80,$z++%y///c,80 until`sleep .1`

ANSI kodları ve coreutils çağrısı için Unix uyumlu bir terminale güvenir sleep. Yukarıdaki iki \x..karakter aslında bu altıgen döküme göre gerçek bir satır besleme ve kaçış karakteridir:

0000000: 245f 3d3c 3e3b 732f 0a2f 202f 3b70 7269  $_=<>;s/./ /;pri
0000010: 6e74 220d 1b5b 3931 6d22 2c73 7562 7374  nt"..[91m",subst
0000020: 7222 245f 2278 3830 2c24 7a2b 2b25 792f  r"$_"x80,$z++%y/
0000030: 2f2f 632c 3830 2075 6e74 696c 6073 6c65  //c,80 until`sle
0000040: 6570 202e 3160                           ep .1`

Yakut, 79 76 75 bayt

t,i=gets.chop*81,0
loop{system'cls'
$><<t[(i=(i+1)%80)..i+79]
sleep 0.1}

Ben hala yakut bir uzman değilim, muhtemelen golf olabilir.

Kırmızı ve siyah aynı puanla:

t,i=gets.chop*81,0
loop{system'cls&color 4'
$><<t[(i=(i+1)%80)..i+79]
sleep 0.1}

Perl, 84 bayt (-% 10 = 76)

$_=' 'x80 .pop;$|=print"\b \r\e[31m".substr$_,++$p% length,80until select$z,$z,$z,.1

Seçim çerçevesindeki metin olan bir komut satırı argümanı alır.

Açıklama:

1. Metne 80 boşluk yerleştirin ve $_
2. Backspace ( \b) ve bir boşluk (( ) . Bu, önceki baskıdaki son karakteri kaldırır. Ardından şaryo dönüşünü ve rengini yazdırın.
3. Metnin 80 karakterini konumdan yazdır $p
4. $p = ($p+1) % length of text
5. 0,1 saniye uyku

bash, 121 bayt

A=$(printf ' %.s' {1..80})$1
while :; do
printf "%s \r" "${A:((P++)):80}"
if [ $P == ${#A} ];then
 P=0
fi
sleep 0.1
done

Python 3, 96 bayt

import time;s=input()*80
while 1:print("\033[2J",end=s[:80],flush=1);s=s[1:]+s[0];time.sleep(.1)

Bu yalnızca ANSI kaçış dizilerini destekleyen terminallerde çalışır. Windows kullanıyorsanız ansicon'u deneyin .

flushPython 3'teki anahtar kelimeye engel olun , bu yüzden pahalı bir sys.stdout.flush()arama yapmak zorunda değiliz .

Cı, 293 269 bayt

(Okunabilirlik için yeni satırlar eklendi)

Bu, girdiyi EOF tarafından sonlandırılan standart girişten alır; bu nedenle bir dize, bir yeni satır ve ardından EOF (örn., Ctrl ^ D) girmek en iyisidir.

#include<stdio.h>
#include<string.h>
#define Z '\0'
main(){int i=0,j;char m[80],o[80],n[2];
while(~(j=getchar())&&i<80)j-'\n'?m[i++]=j:0;m[i]=Z;
while(1){for(i=0;m[i]-Z;++i){strcpy(o,&m[i]);
for(j=0;j<i;)*n=m[j++],n[1]=Z,strcat(o,n);
printf("\x1b[40;31m%s\x1b[0m\r",o);}}}

Ungolfed:

#include <stdio.h>
#include <string.h>
#define ANSI_COLOR_SET "\x1b[40;31m"
#define ANSI_COLOR_RESET "\x1b[0m"

int main(void)
{
  int i, j, c;
  char msg[80], out[80], next[2];

  for (i = 0; (c = getchar()) != EOF && i < 80; ++i) {
    if (c != '\n') {
      msg[i] = c;
    }
  }
  msg[i - 1] = '\0';

  while (1) {
    for (i = 0; msg[i] != '\0'; ++i) {
      strcpy(out, &msg[i]);
      for (j = 0; j < i; ++j) {
        next[0] = msg[j];
        next[1] = '\0';
        strcat(out, next);
      }
      printf(ANSI_COLOR_SET "%s\r" ANSI_COLOR_RESET, out);
    }
  }
  return(0);
}

SmileBASIC BIG, 79 bayt

COLOR 3INPUT S$@L
CLS
FOR I=0TO 79?S$[(I+O)MOD LEN(S$)];
NEXT
WAIT 6O=O+1GOTO@L

Bir kerede 1 karakter kaydırması gerektiğini fark ettiğimde neredeyse güzel bir grafik çözümüm vardı.

Jöle , 20 19 18 bayt

• -1 birinci değiştirerek bayt 80göre ⁹(= 256) ile çarpılan edilecek olan, çünkü en az 80
• Sonsuz döngüyü Çß(itibaren Ç1¿) olarak değiştirerek -1 bayt .

ẋ⁹ḣ80ṙ1;”ÆṄœS.1
Çß

@Dennis'in cevabından bazı püf noktaları ile . Jelly, meydan okumadan daha yenidir, ancak bunun için özel olarak tasarlanmamıştır. Nasıl geliştirileceğine dair önerilerinizi bekliyoruz! Konsolunuz utf-8 içindeyse, export LC_ALL=en_USdenemeden önce çalıştırın veya benzeri.

Misal

açıklama

ẋ⁹ḣ80ṙ1;”ÆṄœS.1         Monadic helper link - Argument: s
ẋ⁹                      Repeat s 256 times.
  ḣ80                   Head. Set {output} to first 80 characters from repeated s.
     ṙ1                 Rotate. Rotates {output} one character to the left.
       ;Ӯ              Concatenate character 0D, the carriage return, to {output}.
          Ṅ             Print and return {output}.
           œS.1         Wait 0.1 seconds before returning {output} from the
                        helper link.

Çß                      Monadic main link - Argument: s
Ç                       Execute helper link with argument s. Replace s by
                        result of helper link.
 ß                      Execute this link with argument s (while true).

LOVE2D Lua,% 197-10 = 178 Bayt

f=io.open("t.t"):read().."  "love.graphics.setColor(255,0,0)love.window.setMode(640,14)function love.draw()s=""for i=1,80 do n=i+os.clock()s=s..f:sub(n%#f,n%#f) end love.graphics.print(s,0,0)end

Girişin kökte 'tt' adlı bir dosyada olmasını gerektirir, böylece skora 3 ekstra bayt eklenir.

Gerçekten 80 temel yinelemeli bir döngü için, temel işlevsellik i i indeksi artı geçerli dizinin uzunluğu tarafından modüle saniye cinsinden geçerli zaman eklemek, girişin tekrarlanan 80 karakter uzunluğunda bir dize vererek, sola kayar zaman geçtikçe.

LOVE2D'yi gülüşler için kullandım.

Sinclair ZX81 / Timex TS1000 / 1500 BASIC, 110 bayt 182 bayt (listeleme için)

1 LET A$="I LIKE TO SCROLL IT... HELLO MUM, BY DONKEYSOFT... THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG... STILL SCROLLING... "
2 PRINT AT 0,0;A$(1 TO 80)
3 LET A$=A$(2 TO )+A$(1)
4 GOTO 3

Dizenin ilk 32 80 karakterini A$ekran satırında 0,0 ekran konumuna iki satırda yazdırarak ve ardından dizeyi satır 2'den satır 3'teki sokmanın sonuna kadar değiştirerek çalışır (Sinclair ZX81 BASIC, dizeleri sıfırdan değil 1'den dizine ekler ), böylece birinci karakteri sonuna ekleme ve A$değişkene geri aktarma ; 2. satıra geri gelen koşulsuz bir döngü var.

Commodore 64, 434 bayt

0 A$="I LIKE TO SCROLL IT... SAMPLE SCROLLY ROUTINE FOR CODE-GOLF MADE BY DONKEYS
1 A$=A$+"OFT MMXVII... HELLO MUM... SCROLLING IS FUN, INNIT? GREETZ TO ALL...
2 POKE53280,6:PRINT"{CLEAR}";
3 PRINTLEFT$(A$,40)"{HOME}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}"MID$(A$,41,40)"{HOME}";
4 FORI=0TO99:NEXT:A$=RIGHT$(A$,142)+LEFT$(A$,1):GOTO3

Bu, 80 karakterin gösterilmesini gerektirdiğinden ve varsayılan olarak C64 yalnızca 40 karakter olduğundan, ekranın üst satırına 40 karakter kaydırılırken, diğer 40 karakter alt tarafa yakın yazdırılır.

{HOME}PETSCII olarak ve diğer sembollerin ne anlama geldiğini temizlemek için emülatörümden alınan bir ekran görüntüsü:

CBM PRG Studio'yu yüklediğimde (veya iş yerinde öğle yemeğinde olmadığımda) tam bir golf versiyonunu yapacağım.

Yakut, 79 77 karakter

->(s){t=0;loop{system("clear");puts (s*80)[t..(80+t)];t=(t+1)%80;sleep(0.1)}}

PHP, 136 bayt

<?php
$s="\e[0;31;40m".substr(str_repeat($argv[1],160),0,160);
while(true){for($i=0;$i<=80;$i++){usleep(100000);echo substr($s,$i)."\r";}}die;

• İle ara php -f marquee.php hello\ world"Merhaba dünya" dizesini kayan yazı .
• Nedense, ilk dize için 160 karakter yapmak zorunda kaldı, aksi takdirde çıktı gibi bir şey olurdu hello worlddddddddddddddddddddddddddddddddddddddd, ama sadece 80 karakter arasında döngü olacak - umarım hala önemlidir.

Uzun bir gündü, muhtemelen onu geliştirmek için yapabileceğim bir şey var

PHP, 85 bayt

for(;;usleep(1e5))echo substr(str_repeat($s=$argv[1],80),$i=++$i%strlen($s),80),"\r";

ilk komut satırı bağımsız değişkeninden girdi alır; ile koş-nr .

İkinci karakterle kaydırmayı başlatır. İlk karakterde başlatmak için bir bayt ekleyin:
Değiştir =++$i%ile %=ve ;;ile ;;$i++,.