Nota listesini çıkar

27

Bu görev basittir: Tüm müzik notalarının listesini (İngilizce not adlarını kullanarak) A'dan G'ye kadar çıkaran bir program veya işlev yazın.

Tek bir harften oluşan bir adı olmayan tüm notalar (örneğin, müzik klavyesindeki siyah notalar), ismin bir defa nota, iki defa da bir nota kadar iki kez basılmış olması gerekir. B letter (C) veya F ♭ (E) gibi tek bir harfle tanımlanabilecek keskin veya düz notlar basılmamalıdır.

İşte çıktının bir örneği:

Ab, A, A#, Bb, B, C, C#, Db, D, D#, Eb, E, F, F#, Gb, G, G#

Özellikler

  • Program veya işlev herhangi bir giriş yapmamalıdır.

  • Notlar, standart G / Ç kurallarımızın izin verdiği herhangi bir sırayla ve herhangi bir listede çıktıyla basılabilir.

  • Keskin ve düz Unicode sembolleri (♯ / ♭), b ve#

  • Her zaman olduğu gibi, standart boşluklar yasaktır.

  • Bu kod golf olduğundan , bayt cinsinden en küçük program kazanır.

code-golf  kolmogorov-complexity 
— TheOnlyMrCat
kaynak
3
— Jonathan Allan
1
"C "Bunun yerine çıktı alabilir miyiz "C"?
— Arnauld,
1
@Arnauld evet siz olabilirsiniz
— TheOnlyMrCat
7
Bu arada, B # müzik notasyonunda var; Mesela, lider ton olarak görev yaptığı C # anahtarının anahtar imzasında.
— Kaz
2
Bilmiyorum, burada
— Cb'nin

Yanıtlar:

13

Malbolge , 482 370 353 bayt

R1: Arası kaldırıldı virgüller (mücadelenin gerektirmediği şekilde)

R2: Bir kaç baytı tıraş et

('<;_#!=6Z|{8xUwvt,PrqonKmk)"FhCUTdb?`+<;:[Z7YtVU2T|/g-O+i(gJrHc#EC~B{@zZxw:tt'r5Qo"!l/K-hUfe?bP``_Lo~[}|X2VCTR3Q+N`_^9+7Hji3ffdAc~w|u;]\wpon4VUSSQ.PONcb(JI^]#DCYX|@?>=<:u9NMRKo32MFj.C,Ae)>'<%:^"!~5:3WxwwuRts0q(Lnml)"Fhgfe"y?a`_zyxq7YXWlUj0RgfkjMb(JI^c\[Z~BAV?T=Rv987Mq44310FEi-,G@)>b&%#"8=6Z{{yyw/Sut1*)('Km$k(!Efe{zyx>`uz]r8ZXnm3TTih.PkNchg`&HFF[DY}Az

Çevrimiçi deneyin!

— Krzysztof Szewczyk
kaynak
12

CP-1610 montajı ( Intellivision ), 31 DECLEs 1 = 39 bayt

R4'te bir çıkış göstergesini alan ve orada notları boşluklarla ayırarak yazan bir yordam . Örnek kodda, doğrudan ekrana yazıyoruz.

Hex dökümü (yalnızca rutin)

275 001 2BD 03C 048 1DB 2B8 012 044 2A9 2BA 108 078 201 003 262
261 263 2FA 008 37A 140 225 00B 089 22C 011 2B7 018 210 000

Tam kaynak

                ROMW    10              ; use 10-bit ROM width
                ORG     $4800           ; map this program at $4800

                ;; ------------------------------------------------------------- ;;
                ;;  test code                                                    ;;
                ;; ------------------------------------------------------------- ;;
4800            SDBD                    ; set up an interrupt service routine
4801            MVII    #isr,     R0    ; to do some minimal STIC initialization
4804            MVO     R0,       $100
4806            SWAP    R0
4807            MVO     R0,       $101

4809            EIS                     ; enable interrupts

480A            MVII    #$200,    R4    ; R4 = backtab pointer
480C            CALL    notes           ; invoke our routine

480F            DECR    R7              ; loop forever

                ;; ------------------------------------------------------------- ;;
                ;;  ISR                                                          ;;
                ;; ------------------------------------------------------------- ;;
      isr       PROC

4810            MVO     R0,       $0020 ; enable display

4812            CLRR    R0
4813            MVO     R0,       $0030 ; no horizontal delay
4815            MVO     R0,       $0031 ; no vertical delay
4817            MVO     R0,       $0032 ; no border extension
4819            MVII    #$D,      R0
481B            MVO     R0,       $0028 ; light-blue background
481D            MVO     R0,       $002C ; light-blue border

481F            JR      R5              ; return from ISR

                ENDP

                ;; ------------------------------------------------------------- ;;
                ;;  routine                                                      ;;
                ;; ------------------------------------------------------------- ;;
      notes     PROC

4820            PSHR    R5              ; save return address

4821            SDBD                    ; R5 = pointer to @@chr
4822            MVII    #@@chr,   R5
4825            CLRR    R3              ; R3 = 0 (space)
4826            MVII    #$12,     R0    ; R0 = bitmask = $12
4828            SWAP    R0,       2     ; extend it to $1212

4829  @@loop    MVI@    R5,       R1    ; R1 = next symbol
482A            MVII    #('A'-32)*8, R2 ; R2 = 'A' character

482C  @@note    SARC    R0              ; right shift the bitmask
482D            BC      @@next          ; skip this note if the carry is set

482F            MVO@    R2,       R4    ; append the note
4830            MVO@    R1,       R4    ; append the symbol
4831            MVO@    R3,       R4    ; append a space

4832  @@next    ADDI    #8,       R2    ; advance to the next note
4834            CMPI    #('H'-32)*8, R2 ; is it now a 'H'?
4836            BLT     @@note          ; if not, process the inner loop

4838            TSTR    R1              ; was the symbol a space?
4839            BNEQ    @@loop          ; if not, process the outer loop

483B            PULR    R7              ; return

483C  @@chr     DECLE   ('#'-32)*8      ; '#'
483D            DECLE   ('b'-32)*8      ; 'b'
483E            DECLE   0               ; space

                ENDP

Çıktı

çıktı

ekran görüntüsü jzIntv

1. Bir CP-1610 opcode 'DECLE' olarak bilinen 10 bitlik bir değerle kodlanmıştır. Bu rutin 31 DECLEs uzunluğunda, 4820 $ 'dan başlayıp 483E $' da bitiyor (dahil).

— Arnauld
kaynak
7

05AB1E , 16 15 13 bayt

Au…b #âŽ7×bûÏ

@ Maxb sayesinde -2 bayt .

Çevrimiçi deneyin.

Tek karakterli notların sonunda boşluk olan bir liste halinde çıkar.

Açıklama:

Au             # Push the lowercase alphabet, and uppercase it
  …b #         # Push string "b #"
      â        # Take the cartesian product of both strings to create all possible pairs:
               #  ["Ab","A ","A#","Bb","B ","B#",...,"Zb","Z ","Z#"]
       Ž7×     # Push compressed integer 1999
          b    # Convert it to a binary string "11111001111"
           û   # Palindromize it to "111110011111110011111"
            Ï  # Only leave the notes in the list at the truthy values (1), (the trailing
               # items beyond the length of this binary string are also discarded)
               # (after which the result is output implicitly)

Bunun neden Ž7×olduğunu anlamak için bu 05AB1E ucuna bakın ( büyük tam sayıların sıkıştırılması nasıl yapılır? )1999 .

Ž7×alternatif olarak ₄·<aynı bayt sayısı için (1000, çift, 1 azalış) olabilir.

— Kevin Cruijssen
kaynak
3
Mı 7£gerçekten gerekli? Onsuz iyi çalışıyor gibi görünüyor.
— Ağustos'ta
6

Jöle , 18? * 20 bayt

ØAḣ7µp⁾b#Żs6ḣ€4ẎḊ;W€

Karakter listelerini döndüren tek parça bir Bağlantı.

* Karışık bir (a) karakter listesi ve (b) karakter listesi kabul edilebilirse W€, 18'deki izi kaldırın .

Çevrimiçi deneyin!

Nasıl?

ØAḣ7µp⁾b#Żs6ḣ€4ẎḊ;W€ - Link: no argument
ØA                   - list of characters     [A-Z]
  ḣ7                 - head to 7              "ABCDEFG"
    µ                - new monadic link (call that X)
      ⁾b#            - list of characters     "b#"
     p               - Cartesian product      ["Ab","A#","Bb","B#","Cb","C#","Db","D#","Eb","E#","Fb","F#","Gb","G#"]
         Ż           - prepend a zero       [0,"Ab","A#","Bb","B#","Cb","C#","Db","D#","Eb","E#","Fb","F#","Gb","G#"]
          s6         - split into sixes    [[0,"Ab","A#","Bb","B#","Cb"],["C#","Db","D#","Eb","E#","Fb"],["F#","Gb","G#"]]
            ḣ€4      - head each to 4      [[0,"Ab","A#","Bb"],["C#","Db","D#","Eb"],["F#","Gb","G#"]]
               Ẏ     - tighten              [0,"Ab","A#","Bb","C#","Db","D#","Eb","F#","Gb","G#"]
                Ḋ    - dequeue                ["Ab","A#","Bb","C#","Db","D#","Eb","F#","Gb","G#"]
                  W€ - wrap each (of X)       ["A","B","C","D","E","F","G"]
                 ;   - concatenate            ["Ab","A#","Bb","C#","Db","D#","Eb","F#","Gb","G#","A","B","C","D","E","F","G"]
— Jonathan Allan
kaynak
@mirabilos bu 20 byte kaynak koddur, Unicode karakterleri her biri kaynak kodun bir baytını temsil eder - bytesbaşlıktaki kelimeye bağlı kod sayfasına bakınız .
— Jonathan Allan
5

Retina 0.8.2 , 33 bayt


ABCDEFG
.
 $&b $& $&#
 [BE]#...

Çevrimiçi deneyin! Açıklama:


ABCDEFG

Temel not adlarını girin.

.
 $&b $& $&#

Düz ve keskin sürümleri içerecek şekilde her notu genişletin.

 [BE]#...

Sil B#, E#onları (şu da notlar Cbve Eb).

— Neil
kaynak
5

Perl 6 , 41 bayt

{S:g/[E|B]\#...//}o{'A'..'G'X~'b #'.comb}

Çevrimiçi deneyin!

Notların basit çapraz çarpımları ve keskin uçların / dairelerin ardından ekstra geçersiz notların alınması. Bu, dizeyi üreten anonim bir kod bloğudur:

Ab A  A# Bb B   C  C# Db D  D# Eb E   F  F# Gb G  G#
— Jo King
kaynak
4

Kömür , 21 bayt

Φ⪪⭆…α⁷⭆b #⁺ι벧↨⊖⊘φ²κ

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

    α                   Predefined variable uppercase alphabet
   … ⁷                  First 7 letters i.e. `ABCEDFG`
  ⭆                     Map over characters and join
       b #              Literal string `b #`
      ⭆                 Map over characters and join
          ⁺ιλ           Concatenate outer and inner characters
 ⪪           ²          Split back into substrings of length 2
Φ                       Filter where nonzero
                  φ     Predefined variable 1000
                 ⊘      Halved i.e. 500
                ⊖       Decremented i.e 499
               ↨   ²    Converted to base 2 i.e. [1, 1, 1, 1, 1, 0, 0, 1, 1]
              §     κ   Cyclically indexed by outer index
                        Implicitly print matching values on separate lines
— Neil
kaynak
3

Japt , 23 22 bayt

;B¯7
ï"b #" fÏÄ %9%8<6

Dene

;B          Alphabet
  ¯7        First seven characters ("ABCDEFG")
            Assign to U
ï"b #"       Cartesian product with "b #" ("Ab,A ,A#,Bb,B ,B#,Cb,C ,C#,Db,D ,D#,Eb,E ,E#,Fb,F ,F#,Gb,G ,G#")
f           Filter:
 ÏÄ           Is index + 1
   %9%8       Mod 9 Mod 8
     <6       Less than 6
            End filter ("Ab,A ,A#,Bb,B ,C ,C#,Db,D ,D#,Eb,E ,F ,F#,Gb,G ,G#")
— Cehalet Tüzüğü
kaynak
Kodunuz içeriyor <6ama <5açıklamada.
— TheOnlyMrCat
@TheOnlyMrCat Düzenlendi
— Ignorance Uygulaması
2

Ruby , 43 bayt

p (2..18).map{|i|"FCGDAEB"[i%7]+"b #"[i/7]}

Çevrimiçi deneyin!

Bu seri ile 0..20tüm daireler, tüm doğal maddeler ve tüm keskinleştiricileri içeren bir dizi yazdırılır. İstenmeyenler Fb Cb E# B#aralık kullanılarak atlanır2..18

Notlar, https://en.wikipedia.org/wiki/Circle_of_fifths veya başka bir deyişle her seferinde 7 yarı ton (yaklaşık olarak tam olarak 1,5 oranında) artan bir sayıya göre yazdırılır .

Bu, verilen not mektubu sırasına yol açar, ki burada her not bir önceki notun üstünde beş derece kapsayıcıdır ("beşinci" olarak bilinir). Örneğin F->CbirFGABC

— Seviye Nehri St
kaynak
Beşe kadar yükselmeni sevdim. Güzel.
— Wayne Conrad
2

brainfuck , 106 bayt

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

Çevrimiçi deneyin!

Satır iadeleriyle ayrılmış her notu çıkarır.

— Jo King
kaynak
2

Zsh , 36 bayt

<<<${${(F):-{A..G}{b,,#}}//[BE]#???}

Çirkin bir çözüm, ancak iki karakter kaydeder. (F)yeni satırlardaki listeye katılır ve //[BE]#???ihtiyacımız olan dizgenin bölümlerini kaldırır.

Çevrimiçi deneyin!

Zsh , 38 bayt

<<<${${:-{A..G}{b,,#}}:#([BE]#|[CF]b)}

Zsh Perl'i yendiğinde her zaman zevk alırım (umarım çok yakında konuşmam ...).

<<<${${:-{A..G}{b,,#}}:#([BE]#|[CF]b)}
     ${:-             }                 # empty-fallback, basically an anonymous parameter expansion
         {A..G}{b,,#}                   # Cross product range A-G with b,(nothing),#
   ${                 :#             }  # Remove matching elements
                        ([BE]#|[CF]b)   # B#, E#, Cb, Fb
<<<                                     # Print to stdout

Çevrimiçi deneyin!

— GammaFunction
kaynak
1

Brachylog , 36 bayt

"#b"ẹ,Ẹ↺;Ṇh₇ᵗ↔{∋ᵐc}ᶠ⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩

Çevrimiçi deneyin!

Ben sürecinde şu anda olduğum zorlaması beni kurtulmak izin verecek Powerset indeksi ⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩(ve uzantısı tarafından ↺çıkış örneği çıkışı ile aynı sırada olması gerekmez, çünkü), ancak oldukça alıyor ... belki de bir liste bırakmalıyım ki, hangi emir listelerinin oluşturulduğunu hesaplayabilir ve indeksi bu şekilde hesaplayabilir ...

— İlgisiz dize
kaynak
1

PHP , 65 bayt

Listeyi bir döngü ile yapar. Öğeler _takip eden bir ayırıcı ile ayrılır.

for(;$l=ABCDEFG[$i++];)echo$l._.[$a="$l#_",$a.$b=$l.b_,$b][$i%3];

Çevrimiçi deneyin!

PHP , 43 bayt

PHP çıkışları şey olarak zaman içinde değil, olduğu <?phpve ?>etiketleri.

Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G#

Çevrimiçi deneyin!

— night2
kaynak
1

Pyth , 23 21 bayt

s<R7c.>*<r1G7"b #"2 9

Çevrimiçi deneyin!

s<R7c.>*<r1G7"b #"2 9   Implicit: G=lowercase alphabet
         r1G            Convert G to upper case
        <   7           First 7 characters
       *     "b #"      Cartesian product with "b #"
     .>           2     Rotate the above 2 places to the right
    c               9   Chop into pieces of length 9
 <R7                    Trim each to length 7
s                       Flatten, implicit print

Düzenleme: 2 bayt kaydetmek için kısmi yeniden yazma, önceki sürüm: s%2c*<r1G7"b #"xLG"fhoq Çevrimiçi deneyin!

— Sok
kaynak
1

Commodore C64 / TheC64 Mini (muhtemelen diğer Commodore 8-bit BASIC varyantları) - 52 tokenize BASIC bayt

 0?"{CTRL+N}Ab A A# Bb B C C# Db D D# Eb E F F# Gb GG#

C64 klavyesinde CTRLartı tuşuna basılması, Nbüyük / küçük harf karakterleri için ayarlanan karakterde 'iş moduna' geçer. Bunu bir bayt / token içindeki bir dizgede yazdırabiliriz; ve 40 sütuna sahip olduğumuz için G'den G # 'ye kadar alan gerekli değildir.

Bu durumda dizgiyi kapatmamıza gerek yoktur, çünkü :ayırıcı ile çok ifadeli bir satır değildir .

Bunun Commodore C64 (ve uyumlu) ekranında nasıl göründüğü aşağıda gösterilmiştir.

Commodore 64 müzik notaları

— Shaun Bebbers
kaynak
1

Fıçı , 43 bayt

Sıkıştırılmış dize.

AbAA\#BbBCC\#DbDD\#EbEFF\#GbGG\#(:H<[ $]')'

TIO

— bir
kaynak
0

Brainfuck, 214 Bayt

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

Çevrimiçi Deneyin!

— Zachary Cotton
kaynak
0

JavaScript (Node.js) , 84 bayt

_=>[...'ABCDEFG'].map((n,i)=>`${i%3!=2?n+'b,':''}${n}${i%3!=1?`,${n}#`:''}`).join`,`

Çevrimiçi deneyin!

Sadece dizgiyi döndürmek (aşağıda gösterildiği gibi) 36 byte daha kısa olacaktır, fakat bunun neresinde eğlence var?

_=>'Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G#'
— T. Dirks
kaynak
0

brainfuck , 255 115 bayt

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

Çevrimiçi deneyin!

— Krzysztof Szewczyk
kaynak
1
Bunu affederdim ama yanlış. B ve C arasında ya da E ile F arasında siyah bir not yoktur. B #, Cb, E # veya Fb. Ayrıca, küçük harf kullanmanın doğru olduğu konusunda hiçbir şey görmüyorum.
— Seviye River St
@LevelRiverSt mücadelesi hiçbir yerde B ile C ve E ve F arasında notları olmadığını belirtmedi
— Krzysztof Szewczyk
All notes without a name consisting of a single letter (i.e. black notes on a musical keyboard) should have their name printed twice, once as the sharp of a note, once as the flat of one. Sharp or flat notes that can be described with a single letter, like B♯ (C) or F♭ (E) should not be outputted.Bu bana oldukça açık görünüyor ve ekranımda OP'de düzenleme geçmişi olmadığını görüyorum.
— Seviye River St,
0

Bash 5 , 42 bayt

x=`echo {A..G}{b,,#}`;echo ${x//[BE]#???/}

Çıktı:

Ab A A# Bb B C C# Db D D# Eb E F F# Gb G G#
— Thorsten
kaynak
0

T-SQL, 124 bayt

SELECT value+a
FROM STRING_SPLIT('A-B-C-D-E-F-G','-')
    ,(VALUES('b'),(''),('#'))b(a)
WHERE value+a NOT IN ('B#','E#','Cb','Fb')

Satır sonları yalnızca görüntüleme amaçlıdır.

Önemsiz sürümden daha uzun ama çok daha ilginç (50 bayt) :

PRINT'Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G#'
— BradC
kaynak
0

Z80Golf , 31 29 bayt

00000000: 9d5b dc6d df7f 0603 3e40 d13c cb3a 3008  .[.m....>@.<.:0.
00000010: fff5 7b2f ffaf fff1 20f1 10ec 76         ..{/.... ...v

Çevrimiçi deneyin!

Açıklama :

Z80Golf, Z80 8-bit işlemciye dayanan basit bir fantazi makinedir. Program hafıza konumuna yüklenir ve hafızanın 0x0000geri kalanı sıfırlarla doldurulur. Çıktı çağırılarak yapılır0x8000 A kaydının değerini karakter olarak veren .

Program, işlenecek verilerle toplam 6 bayt ile başlar. Her bir bayt çifti, bir not sonekini ve bu notla hangi harflerin birleştirilebileceğini kontrol eden bir bit maskesi belirtir. Baytları kaydetmek için, sonek karakteri ters çevrilir ( xor 0xff) - bu, verilerin küçük yan etkilere sahip talimatlar olarak yürütülmesine izin verir ve bu verileri atlayan bir sıçramayı kaldırmayı mümkün kılar:

               ;    GFEDCBA
    db 0xff^'b', 0b01011011 ; Ab Bb Db Eb Gb
    db 0xff^'#', 0b01101101 ; A# C# D# F# G#
    db 0xff^' ', 0b01111111 ; A  B  C  D  E  F  G
skip_data:

İşlemcinin bu kodu çözme şekli:

    sbc a, l  ; a subtraction with carry on registers we don't care about
    ld e, e   ; put the E register back into itself. This instruction is useless
              ; but still exists to make the encoding regular.
    call c, 0xdf6d ; if the carry flag is set, call a function. The carry flag isn't set
              ; because of the initial register values (all zeroes) when the sbc above
              ; was executed
    ld a, a   ; as above, put A back into itself.

Bu veri DE kayıt çiftine bir defada iki bayt okunur. Yığın işaretçisi, bir sonraki öğeye işaret etmek için kullanılır. 0'da başlar ve Z80 tam inen bir yığın kullandığı için, herhangi bir pop bir sonraki veri çiftini okuyacaktır - tüm yığın işlemleri 16-bit'tir.

Dış döngü, B kayıt defterinde Z80'in djnzkomut şeklinde özel destek sağladığı bir azaltma sayacı ile uygulanır :

    ld b, 3
process_pair:
    ...
    djnz process_pair
    halt

Geçerli harf A sicilinde tutulur. Artış, döngünün başlangıcında iyi bir uyum sağladığından, asıl başlangıç ​​değerinden daha az yükleriz A:

process_pair:
    ld a, 'A'-1
    pop de ; D = bitmask, E = suffix character
process_note:
    inc a
    srl d ; put the current bitmask bit in the carry flag
          ; also sets the zero flag if this is the last note in the pair
    jr nc, skip
    ; Print the note. Note that we need to preserve the zero flag to check it in the
    ; loop condition later.
    rst $38 ; Short encoding of call $0038.
            ; Because the program is so short, the memory in the 0038..8000 range
            ; is filled with zeroes, which happens to be the encoding for a no-op.
            ; The execution will therefore fall-through to the character-print hook.
    push af ; Save the letter on the stack (which will be just to the left of the
            ; unprocessed data) to free up A for printing other characters.
            ; (only 16-bit register pairs can be saved, so we also push the flags)
    ld a, e
    cpl     ; Undo the inversion used to make the execution fall-through the data.
            ; Done again each iteration because it takes less bytes to operate
            ; on the A register.
    rst $38 ; Print the suffix.
    xor a   ; Standard assembly practice of setting a register to zero by XORing it
            ; with itself. Saves a byte over a simple `ld a, 0`.
    rst $38 ; Print a null byte as a separator.
    pop af  ; Restore the current letter from the stack.
skip:
    jr nz, process_note ; If the zero flag (last changed at the srl d) is not set,
                        ; loop once again
    djnz process_pair
    halt
— NieDzejkob
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.