Hướng dẫn loop through two arrays at the same time javascript - lặp qua hai mảng cùng một lúc javascript

Tôi muốn xây dựng một vòng lặp

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

var n = [1,2,3,5,7,8,9,11,12,13,14,16,17,18,20,21,22];
var m = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16];

m.forEach(k => {
    n.forEach(i => {
        console.log(i, k)
    });
};

Kết quả cuối cùng nên đầu ra:

1,0
2,1
3,2
5,3
(...)

Thật không may, vòng lặp này không làm điều đó vì một số lý do vì nó lặp lại mỗi số 17 lần.

Tôi còn thiếu gì ở đây?

Vòng lặp qua nhiều mảng đồng thời, bạn được khuyến khích giải quyết nhiệm vụ này theo mô tả nhiệm vụ, sử dụng bất kỳ ngôn ngữ nào bạn có thể biết.
You are encouraged to solve this task according to the task description, using any language you may know.

Vòng lặp qua nhiều mảng & nbsp; (hoặc danh sách hoặc bộ dữ liệu hoặc bất cứ điều gì chúng được gọi bằng ngôn ngữ của bạn) & nbsp; và hiển thị & nbsp; Tôi th & nbsp; yếu tố của mỗi.

Sử dụng ngôn ngữ của bạn & nbsp; "Đối với mỗi" & nbsp; Vòng lặp nếu nó có một, nếu không hãy lặp qua bộ sưu tập theo thứ tự với một số vòng lặp khác.

Đối với ví dụ này, lặp qua các mảng:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Để tạo ra đầu ra:

    aA1
    bB2
    cC3

Nếu có thể, cũng mô tả những gì xảy ra khi các mảng có độ dài khác nhau.

• & nbsp; Vòng lặp qua nhiều mảng đồng thời
• & nbsp; Vòng/phá vỡ
• & nbsp; Vòng lặp/tiếp tục
• & nbsp; Vòng/do-trong khi
• & nbsp; Vòng/xuống cho
• & nbsp; Vòng/cho
• & nbsp; Vòng lặp/cho một bước được chỉ định
• & nbsp; Vòng lặp/foreach
• & nbsp; Vòng lặp/chỉ số vòng lặp gia tăng trong thân vòng lặp
• & nbsp; Vòng/vô hạn
• & nbsp; Vòng/n cộng với một nửa
• & nbsp; Vòng/lồng nhau
• & nbsp; Vòng lặp/while
• & nbsp; Vòng/với nhiều phạm vi
• & nbsp; Vòng lặp/phạm vi sai

11l[edit][edit]

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

aA1
bB2
cC3

Hội đồng 360 [Chỉnh sửa][edit]

*        Loop over multiple arrays simultaneously  09/03/2017
LOOPSIM  CSECT
         USING  LOOPSIM,R12        base register
         LR     R12,R15
         LA     R6,1               i=1
         LA     R7,3               counter=3
LOOP     LR     R1,R6              i
         SLA    R1,1               *2
         LH     R2,R-2(R1)         r(i)
         XDECO  R2,PG              edit r(i)
         LA     R1,S-1(R6)         @s(i) 
         MVC    PG+3(1),0(R1)      output s(i)
         LA     R1,Q-1(R6)         @q(i)
         MVC    PG+7(1),0(R1)      output q(i)
         XPRNT  PG,80              print s(i),q(i),r(i)
         LA     R6,1(R6)           i++
         BCT    R7,LOOP            decrement and loop
         BR     R14                exit
S        DC     C'a',C'b',C'c'
Q        DC     C'A',C'B',C'C'
R        DC     H'1',H'2',H'3'
PG       DC     CL80' '            buffer
         YREGS
         END    LOOPSIM

   a   A   1
   b   B   2
   c   C   3

Hội đồng 8080 [Chỉnh sửa][edit]

8080 không có cơ chế lập chỉ mục nào cả, vì vậy, người ta sẽ lặp lại các mảng bằng cách tăng các con trỏ tại chỗ thay vì làm theo cách này, nhưng nó có thể (chỉ cần thực hiện).

8080 có 7 thanh ghi tám bit (A, B, C, D, E, H, L), sáu trong số đó có thể tạo thành ba cặp 16 bit (BC, DE, HL). Trong số đó, HL là đặc biệt: Chỉ có thể sử dụng cho toán học và nó có thể được sử dụng như một con trỏ (đăng ký giả 8 bit M đề cập đến byte trong bộ nhớ ở

    aA1
    bB2
    cC3

Do đó, mã này giữ chỉ số trong BC và danh sách các mảng trong DE. Truy cập mảng được thực hiện bằng cách tải các con trỏ mảng vào từng cái một, tính toán địa chỉ bằng cách thêm BC vào nó, sau đó tải giá trị thích hợp.

Mã này chỉ đơn giản giả định rằng các mảng có cùng kích thước (

    aA1
    bB2
    cC3

	org	100h
	lxi	b,0	; Let (B)C be the array index
outer:	lxi	d,As	; Use DE to walk the array-of-arrays
inner:	xchg		; Swap DE and HL (array-of-array pointer into HL)
	mov	e,m	; Load low byte of array pointer into E
	inx	h
	mov	d,m	; Load high byte of array pointer into D 
	inx	h
	xchg		; Array base in HL, array-of-array pointer in DE
	mov	a,h	; Is HL 0?
	ora	l
	jz	azero	; If so, we are done.
	dad	b	; Otherwise, add index to array base
	mov	a,m	; Get current item (BC'th item of HL)
	call	chout	; Output
	jmp	inner	; Next array 
azero:	mvi	a,13	; Print newline	
	call	chout
	mvi	a,10
	call	chout
	inr	c	; Increment index (we're only using the low byte)
	mvi	a,Alen	; Is it equal to the length?
	cmp	c
	jnz	outer	; If not, get next item from all the arrays.
	ret		
	;;;	Print character in A, saving all registers.
	;;;	This code uses CP/M to do it.
chout:	push 	psw	; CP/M destroys all registers
	push	b	; Push them all to the stack
	push	d
	push	h
	mvi	c,2	; 2 = print character syscall
	mov	e,a
	call	5
	pop	h	; Restore registers
	pop	d
	pop	b
	pop	psw
	ret
	;;;	Arrays
A1:	db	'a','b','c'
A2:	db	'A','B','C'
A3:	db	'1','2','3'
Alen:	equ	$-A3
	;;;	Zero-terminated array-of-arrays
As:	dw	A1,A2,A3,0

aA1
bB2
cC3

Hội đồng 8086 [Chỉnh sửa][edit]

Bộ xử lý 8086 có hai thanh ghi chỉ mục

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

Khi địa chỉ bộ nhớ, 8086 có thể tự động thêm lên: 1) một trong

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

Mã này sử dụng

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

1,0
2,1
3,2
5,3
(...)

aA1
bB2
cC3

ACL2[edit][edit]

1,0
2,1
3,2
5,3
(...)

Action![edit][edit]

1,0
2,1
3,2
5,3
(...)

Ảnh chụp màn hình từ máy tính Atari 8 bit

aA1
bB2
cC3

Ada[edit][edit]

1,0
2,1
3,2
5,3
(...)

Algol 68 [Chỉnh sửa][edit]

Hoạt động với: Algol 68 Phiên bản sửa đổi 1 - Không có tiện ích mở rộng cho ngôn ngữ được sử dụng: ALGOL 68 version Revision 1 - no extensions to language used

1,0
2,1
3,2
5,3
(...)

aA1
bB2
cC3

Algol W [Chỉnh sửa][edit]

1,0
2,1
3,2
5,3
(...)

Nếu các mảng không có cùng độ dài, lỗi phạm vi chỉ số sẽ xảy ra khi một phần tử không tồn tại được truy cập.

Hopper tuyệt vời [chỉnh sửa][edit]

Versión 1: Todos los mảng tienen el mismo Tamaño:

1,0
2,1
3,2
5,3
(...)

aA1
bB2
cC3

Versión 2: Los Arrays Tienen Distinto Tamaño:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

APL[edit][edit]

Trong APL, người ta sẽ không sử dụng một vòng lặp rõ ràng cho việc này. Thay vào đó, có một hàm tích hợp để biến một vectơ vectơ thành ma trận, đó là

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

Nếu các vectơ đầu vào không có cùng kích thước, các vectơ ngắn hơn sẽ được đệm với các giá trị trống (khoảng trắng cho các vectơ ký tự, 0 cho các vectơ số) để phù hợp với vectơ dài nhất.

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

AppleScript[edit][edit]

(Phiên bản es 5 ziplistswith chức năng)

Nếu chúng ta có chức năng bản đồ Applescript chung, chúng ta có thể sử dụng nó để viết một ziplistswith chung, áp dụng một hàm nhất định trên các danh sách có nguồn gốc từ các thành viên thứ n của danh sách danh sách (độ dài bằng nhau) tùy ý. (Trường hợp danh sách có độ dài không đồng đều, các mục vượt quá độ dài chia sẻ tối đa bị bỏ qua).map function, we can use it to write a generic zipListsWith, which applies a given function over lists derived from the nth members of an arbitrary list of (equal-length) lists. (Where lists are of uneven length, items beyond the maximum shared length are ignored).

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Nhưng một hàm chuyển vị có thể đơn giản hơn:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Arturo[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

AutoHotkey[edit][edit]

Pseudo-arrays[edit][edit]

Stringsplit tạo ra một mép giả

    aA1
    bB2
    cC3

Một mảng quá ngắn về sáng tạo sẽ trả lại các chuỗi trống khi cố gắng truy xuất các yếu tố tiếp theo. Hộp tin nhắn thứ 2 hiển thị:

    aA1
    bB2
    cC3

Mảng thực [chỉnh sửa][edit]

Trong AutoHotKey_L, chúng ta có thể sử dụng các mảng thực (đối tượng) và vòng lặp cho.

    aA1
    bB2
    cC3

Đầu ra từ tập lệnh này giống hệt với cái đầu tiên.

AWK[edit][edit]

    aA1
    bB2
    cC3

Axe[edit][edit]

Lưu ý rằng trong ví dụ này, chúng tôi sử dụng một vài byte từ mỗi L₁, L₂ và L₃ để đơn giản. Trong thực tế, người ta sẽ muốn sắp xếp các mảng cho tất cả các phù hợp trong L₁ để tránh các vấn đề biến động với L₂ và L₃.

    aA1
    bB2
    cC3

Babel[edit][edit]

Có hai cách để làm điều này trong Babel. Đầu tiên, bạn có thể chuyển đổi danh sách:

    aA1
    bB2
    cC3

Toán tử 'trans' thay thế nil trong các phần của mỗi cột được chuyển đổi bất cứ nơi nào một danh sách hàng ngắn hơn danh sách hàng dài nhất. Các '

Một giải pháp theo nghĩa đen hơn cho vấn đề như được trình bày sẽ được lặp lại trên mỗi danh sách bằng cách sử dụng toán tử CDRALL do người dùng định nghĩa:

    aA1
    bB2
    cC3

Giải pháp này chính thức giống hệt với đầu tiên và sẽ xử lý các danh sách các độ dài khác nhau bằng cách in chèn NIL và không in gì cho đầu đuôi

    aA1
    bB2
    cC3

Danh sách ngắn.

BaCon[edit][edit]

    aA1
    bB2
    cC3

BASIC256[edit][edit]

    aA1
    bB2
    cC3

aA1
bB2
cC3

BBC BASIC [EDIT][edit]

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

Beads[edit][edit]

Giải pháp này chiếm các mảng có độ dài khác nhau và nếu chúng được xen kẽ với các ký tự không xác định bằng cách thay thế chúng bằng không gian.

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Befunge[edit][edit]

Không có khái niệm về kiểu dữ liệu mảng trong befunge, nhưng bạn thường lưu trữ các mảng của mình dưới dạng chuỗi dữ liệu trong không gian mã Befunge. Sau đó, bạn sẽ lặp qua phạm vi các chỉ số cần thiết để truy cập các mảng đó và sử dụng biến vòng lặp làm phần bù vào từng vùng dữ liệu. Đối với các mảng có độ dài khác nhau, bạn cần kiểm tra thủ công một chỉ mục ngoài phạm vi và đối phó với nó một cách thích hợp.

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

C[edit][edit]

Với một số mảng, đặc biệt nếu chúng không đồng nhất, cách thông thường nhất để lặp qua tất cả chúng là chỉ cần sử dụng một biến chỉ mục. Xác định khi nào nên dừng thường được thực hiện theo một số cách cụ thể của ứng dụng.

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

(Lưu ý: Một số trình biên dịch có thể yêu cầu một lá cờ chấp nhận mã C hiện đại này, chẳng hạn như

    aA1
    bB2
    cC3

Mặt khác, có thể viết một sơ đồ lặp theo thứ tự cao hơn, như được thể hiện trong ví dụ này.

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

Mảng ngắn nhất.

C#[edit][edit]

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

Sử dụng Enumable.zip (dừng khi một trong hai nguồn hết các phần tử):

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

Giống như cách một lập trình viên Perl sẽ viết nó (vẫn sử dụng zip):

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

Thực hiện tùy chỉnh cho các mảng có độ dài khác nhau mà các miếng đệm có khoảng trống sau khi kết thúc các mảng ngắn hơn:

aA1
bB2
cC3

cách sử dụng:

aA1
bB2
cC3

C++[edit][edit]

Với

    aA1
    bB2
    cC3

aA1
bB2
cC3

Sử dụng các mảng tĩnh:

aA1
bB2
cC3

C++11[edit][edit]

Với

    aA1
    bB2
    cC3

aA1
bB2
cC3

Sử dụng các mảng tĩnh:

aA1
bB2
cC3

Với

    aA1
    bB2
    cC3

aA1
bB2
cC3

Với

    aA1
    bB2
    cC3

aA1
bB2
cC3

C++23[edit][edit]

aA1
bB2
cC3

Chapel[edit][edit]

aA1
bB2
cC3

Clojure[edit][edit]

*        Loop over multiple arrays simultaneously  09/03/2017
LOOPSIM  CSECT
         USING  LOOPSIM,R12        base register
         LR     R12,R15
         LA     R6,1               i=1
         LA     R7,3               counter=3
LOOP     LR     R1,R6              i
         SLA    R1,1               *2
         LH     R2,R-2(R1)         r(i)
         XDECO  R2,PG              edit r(i)
         LA     R1,S-1(R6)         @s(i) 
         MVC    PG+3(1),0(R1)      output s(i)
         LA     R1,Q-1(R6)         @q(i)
         MVC    PG+7(1),0(R1)      output q(i)
         XPRNT  PG,80              print s(i),q(i),r(i)
         LA     R6,1(R6)           i++
         BCT    R7,LOOP            decrement and loop
         BR     R14                exit
S        DC     C'a',C'b',C'c'
Q        DC     C'A',C'B',C'C'
R        DC     H'1',H'2',H'3'
PG       DC     CL80' '            buffer
         YREGS
         END    LOOPSIM

Trình tự dừng lại khi danh sách ngắn nhất cạn kiệt.

*        Loop over multiple arrays simultaneously  09/03/2017
LOOPSIM  CSECT
         USING  LOOPSIM,R12        base register
         LR     R12,R15
         LA     R6,1               i=1
         LA     R7,3               counter=3
LOOP     LR     R1,R6              i
         SLA    R1,1               *2
         LH     R2,R-2(R1)         r(i)
         XDECO  R2,PG              edit r(i)
         LA     R1,S-1(R6)         @s(i) 
         MVC    PG+3(1),0(R1)      output s(i)
         LA     R1,Q-1(R6)         @q(i)
         MVC    PG+7(1),0(R1)      output q(i)
         XPRNT  PG,80              print s(i),q(i),r(i)
         LA     R6,1(R6)           i++
         BCT    R7,LOOP            decrement and loop
         BR     R14                exit
S        DC     C'a',C'b',C'c'
Q        DC     C'A',C'B',C'C'
R        DC     H'1',H'2',H'3'
PG       DC     CL80' '            buffer
         YREGS
         END    LOOPSIM

COBOL[edit][edit]

*        Loop over multiple arrays simultaneously  09/03/2017
LOOPSIM  CSECT
         USING  LOOPSIM,R12        base register
         LR     R12,R15
         LA     R6,1               i=1
         LA     R7,3               counter=3
LOOP     LR     R1,R6              i
         SLA    R1,1               *2
         LH     R2,R-2(R1)         r(i)
         XDECO  R2,PG              edit r(i)
         LA     R1,S-1(R6)         @s(i) 
         MVC    PG+3(1),0(R1)      output s(i)
         LA     R1,Q-1(R6)         @q(i)
         MVC    PG+7(1),0(R1)      output q(i)
         XPRNT  PG,80              print s(i),q(i),r(i)
         LA     R6,1(R6)           i++
         BCT    R7,LOOP            decrement and loop
         BR     R14                exit
S        DC     C'a',C'b',C'c'
Q        DC     C'A',C'B',C'C'
R        DC     H'1',H'2',H'3'
PG       DC     CL80' '            buffer
         YREGS
         END    LOOPSIM

Lisp thông thường [Chỉnh sửa][edit]

Sử dụng ứng dụng chức năng [Chỉnh sửa][edit]

*        Loop over multiple arrays simultaneously  09/03/2017
LOOPSIM  CSECT
         USING  LOOPSIM,R12        base register
         LR     R12,R15
         LA     R6,1               i=1
         LA     R7,3               counter=3
LOOP     LR     R1,R6              i
         SLA    R1,1               *2
         LH     R2,R-2(R1)         r(i)
         XDECO  R2,PG              edit r(i)
         LA     R1,S-1(R6)         @s(i) 
         MVC    PG+3(1),0(R1)      output s(i)
         LA     R1,Q-1(R6)         @q(i)
         MVC    PG+7(1),0(R1)      output q(i)
         XPRNT  PG,80              print s(i),q(i),r(i)
         LA     R6,1(R6)           i++
         BCT    R7,LOOP            decrement and loop
         BR     R14                exit
S        DC     C'a',C'b',C'c'
Q        DC     C'A',C'B',C'C'
R        DC     H'1',H'2',H'3'
PG       DC     CL80' '            buffer
         YREGS
         END    LOOPSIM

Nếu danh sách có độ dài khác nhau, nó dừng lại sau cái ngắn nhất.

Sử dụng Loop [Chỉnh sửa][edit]

*        Loop over multiple arrays simultaneously  09/03/2017
LOOPSIM  CSECT
         USING  LOOPSIM,R12        base register
         LR     R12,R15
         LA     R6,1               i=1
         LA     R7,3               counter=3
LOOP     LR     R1,R6              i
         SLA    R1,1               *2
         LH     R2,R-2(R1)         r(i)
         XDECO  R2,PG              edit r(i)
         LA     R1,S-1(R6)         @s(i) 
         MVC    PG+3(1),0(R1)      output s(i)
         LA     R1,Q-1(R6)         @q(i)
         MVC    PG+7(1),0(R1)      output q(i)
         XPRNT  PG,80              print s(i),q(i),r(i)
         LA     R6,1(R6)           i++
         BCT    R7,LOOP            decrement and loop
         BR     R14                exit
S        DC     C'a',C'b',C'c'
Q        DC     C'A',C'B',C'C'
R        DC     H'1',H'2',H'3'
PG       DC     CL80' '            buffer
         YREGS
         END    LOOPSIM

Sử dụng DO [Chỉnh sửa][edit]

*        Loop over multiple arrays simultaneously  09/03/2017
LOOPSIM  CSECT
         USING  LOOPSIM,R12        base register
         LR     R12,R15
         LA     R6,1               i=1
         LA     R7,3               counter=3
LOOP     LR     R1,R6              i
         SLA    R1,1               *2
         LH     R2,R-2(R1)         r(i)
         XDECO  R2,PG              edit r(i)
         LA     R1,S-1(R6)         @s(i) 
         MVC    PG+3(1),0(R1)      output s(i)
         LA     R1,Q-1(R6)         @q(i)
         MVC    PG+7(1),0(R1)      output q(i)
         XPRNT  PG,80              print s(i),q(i),r(i)
         LA     R6,1(R6)           i++
         BCT    R7,LOOP            decrement and loop
         BR     R14                exit
S        DC     C'a',C'b',C'c'
Q        DC     C'A',C'B',C'C'
R        DC     H'1',H'2',H'3'
PG       DC     CL80' '            buffer
         YREGS
         END    LOOPSIM

aA1
bB2
cC3

D[edit][edit]

*        Loop over multiple arrays simultaneously  09/03/2017
LOOPSIM  CSECT
         USING  LOOPSIM,R12        base register
         LR     R12,R15
         LA     R6,1               i=1
         LA     R7,3               counter=3
LOOP     LR     R1,R6              i
         SLA    R1,1               *2
         LH     R2,R-2(R1)         r(i)
         XDECO  R2,PG              edit r(i)
         LA     R1,S-1(R6)         @s(i) 
         MVC    PG+3(1),0(R1)      output s(i)
         LA     R1,Q-1(R6)         @q(i)
         MVC    PG+7(1),0(R1)      output q(i)
         XPRNT  PG,80              print s(i),q(i),r(i)
         LA     R6,1(R6)           i++
         BCT    R7,LOOP            decrement and loop
         BR     R14                exit
S        DC     C'a',C'b',C'c'
Q        DC     C'A',C'B',C'C'
R        DC     H'1',H'2',H'3'
PG       DC     CL80' '            buffer
         YREGS
         END    LOOPSIM

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Zip () cho phép chỉ định chính sách dừng. Theo mặc định, nó dừng lại khi phạm vi ngắn nhất bị cạn kiệt (giống như stoppingpolicy.shortest):

*        Loop over multiple arrays simultaneously  09/03/2017
LOOPSIM  CSECT
         USING  LOOPSIM,R12        base register
         LR     R12,R15
         LA     R6,1               i=1
         LA     R7,3               counter=3
LOOP     LR     R1,R6              i
         SLA    R1,1               *2
         LH     R2,R-2(R1)         r(i)
         XDECO  R2,PG              edit r(i)
         LA     R1,S-1(R6)         @s(i) 
         MVC    PG+3(1),0(R1)      output s(i)
         LA     R1,Q-1(R6)         @q(i)
         MVC    PG+7(1),0(R1)      output q(i)
         XPRNT  PG,80              print s(i),q(i),r(i)
         LA     R6,1(R6)           i++
         BCT    R7,LOOP            decrement and loop
         BR     R14                exit
S        DC     C'a',C'b',C'c'
Q        DC     C'A',C'B',C'C'
R        DC     H'1',H'2',H'3'
PG       DC     CL80' '            buffer
         YREGS
         END    LOOPSIM

   a   A   1
   b   B   2
   c   C   3

Tiếp theo là một ngoại lệ với thông điệp "phạm vi độ dài không đồng đều được truyền đến ZIP".

Ngoài ra còn có std.range.lockstep:

   a   A   1
   b   B   2
   c   C   3

Mã cấp thấp hơn dừng ở độ dài ngắn nhất:

   a   A   1
   b   B   2
   c   C   3

   a   A   1
   b   B   2
   c   C   3

Delphi[edit][edit]

   a   A   1
   b   B   2
   c   C   3

Diego[edit][edit]

   a   A   1
   b   B   2
   c   C   3

Diego không có vấn đề gì khi các mảng có độ dài khác nhau, các mục mảng "bị thiếu" sẽ được xử lý là trống. Lưu ý,

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

   a   A   1
   b   B   2
   c   C   3

   a   A   1
   b   B   2
   c   C   3

DWScript[edit][edit]

Nếu các mảng không có cùng giới hạn, một chỉ mục ngoài ngoại lệ sẽ được kích hoạt khi cố gắng truy cập một phần tử không tồn tại.

   a   A   1
   b   B   2
   c   C   3

E[edit][edit]

E thiếu một cách tốt đẹp để làm điều này; Đây là [http://wiki.erights.org/wiki/parallel_itation để được sửa chữa, một khi chúng ta tìm ra những việc cần làm]. Tuy nhiên, việc lặp lại trong danh sách tạo ra các chỉ mục của nó dưới dạng các khóa, do đó, một thành ngữ không hoàn toàn khủng khiếp tồn tại:

   a   A   1
   b   B   2
   c   C   3

Điều này rõ ràng sẽ thất bại nếu A2 hoặc A3 ngắn hơn A1 và bỏ qua các mục

	org	100h
	lxi	b,0	; Let (B)C be the array index
outer:	lxi	d,As	; Use DE to walk the array-of-arrays
inner:	xchg		; Swap DE and HL (array-of-array pointer into HL)
	mov	e,m	; Load low byte of array pointer into E
	inx	h
	mov	d,m	; Load high byte of array pointer into D 
	inx	h
	xchg		; Array base in HL, array-of-array pointer in DE
	mov	a,h	; Is HL 0?
	ora	l
	jz	azero	; If so, we are done.
	dad	b	; Otherwise, add index to array base
	mov	a,m	; Get current item (BC'th item of HL)
	call	chout	; Output
	jmp	inner	; Next array 
azero:	mvi	a,13	; Print newline	
	call	chout
	mvi	a,10
	call	chout
	inr	c	; Increment index (we're only using the low byte)
	mvi	a,Alen	; Is it equal to the length?
	cmp	c
	jnz	outer	; If not, get next item from all the arrays.
	ret		
	;;;	Print character in A, saving all registers.
	;;;	This code uses CP/M to do it.
chout:	push 	psw	; CP/M destroys all registers
	push	b	; Push them all to the stack
	push	d
	push	h
	mvi	c,2	; 2 = print character syscall
	mov	e,a
	call	5
	pop	h	; Restore registers
	pop	d
	pop	b
	pop	psw
	ret
	;;;	Arrays
A1:	db	'a','b','c'
A2:	db	'A','B','C'
A3:	db	'1','2','3'
Alen:	equ	$-A3
	;;;	Zero-terminated array-of-arrays
As:	dw	A1,A2,A3,0

Với một tiện ích lặp song song, chúng tôi có thể viết điều này:

	org	100h
	lxi	b,0	; Let (B)C be the array index
outer:	lxi	d,As	; Use DE to walk the array-of-arrays
inner:	xchg		; Swap DE and HL (array-of-array pointer into HL)
	mov	e,m	; Load low byte of array pointer into E
	inx	h
	mov	d,m	; Load high byte of array pointer into D 
	inx	h
	xchg		; Array base in HL, array-of-array pointer in DE
	mov	a,h	; Is HL 0?
	ora	l
	jz	azero	; If so, we are done.
	dad	b	; Otherwise, add index to array base
	mov	a,m	; Get current item (BC'th item of HL)
	call	chout	; Output
	jmp	inner	; Next array 
azero:	mvi	a,13	; Print newline	
	call	chout
	mvi	a,10
	call	chout
	inr	c	; Increment index (we're only using the low byte)
	mvi	a,Alen	; Is it equal to the length?
	cmp	c
	jnz	outer	; If not, get next item from all the arrays.
	ret		
	;;;	Print character in A, saving all registers.
	;;;	This code uses CP/M to do it.
chout:	push 	psw	; CP/M destroys all registers
	push	b	; Push them all to the stack
	push	d
	push	h
	mvi	c,2	; 2 = print character syscall
	mov	e,a
	call	5
	pop	h	; Restore registers
	pop	d
	pop	b
	pop	psw
	ret
	;;;	Arrays
A1:	db	'a','b','c'
A2:	db	'A','B','C'
A3:	db	'1','2','3'
Alen:	equ	$-A3
	;;;	Zero-terminated array-of-arrays
As:	dw	A1,A2,A3,0

    aA1
    bB2
    cC3

	org	100h
	lxi	b,0	; Let (B)C be the array index
outer:	lxi	d,As	; Use DE to walk the array-of-arrays
inner:	xchg		; Swap DE and HL (array-of-array pointer into HL)
	mov	e,m	; Load low byte of array pointer into E
	inx	h
	mov	d,m	; Load high byte of array pointer into D 
	inx	h
	xchg		; Array base in HL, array-of-array pointer in DE
	mov	a,h	; Is HL 0?
	ora	l
	jz	azero	; If so, we are done.
	dad	b	; Otherwise, add index to array base
	mov	a,m	; Get current item (BC'th item of HL)
	call	chout	; Output
	jmp	inner	; Next array 
azero:	mvi	a,13	; Print newline	
	call	chout
	mvi	a,10
	call	chout
	inr	c	; Increment index (we're only using the low byte)
	mvi	a,Alen	; Is it equal to the length?
	cmp	c
	jnz	outer	; If not, get next item from all the arrays.
	ret		
	;;;	Print character in A, saving all registers.
	;;;	This code uses CP/M to do it.
chout:	push 	psw	; CP/M destroys all registers
	push	b	; Push them all to the stack
	push	d
	push	h
	mvi	c,2	; 2 = print character syscall
	mov	e,a
	call	5
	pop	h	; Restore registers
	pop	d
	pop	b
	pop	psw
	ret
	;;;	Arrays
A1:	db	'a','b','c'
A2:	db	'A','B','C'
A3:	db	'1','2','3'
Alen:	equ	$-A3
	;;;	Zero-terminated array-of-arrays
As:	dw	A1,A2,A3,0

Danh sách, như dưới đây. Cả một định nghĩa cho bất kỳ số lượng bộ sưu tập và hai

	org	100h
	lxi	b,0	; Let (B)C be the array index
outer:	lxi	d,As	; Use DE to walk the array-of-arrays
inner:	xchg		; Swap DE and HL (array-of-array pointer into HL)
	mov	e,m	; Load low byte of array pointer into E
	inx	h
	mov	d,m	; Load high byte of array pointer into D 
	inx	h
	xchg		; Array base in HL, array-of-array pointer in DE
	mov	a,h	; Is HL 0?
	ora	l
	jz	azero	; If so, we are done.
	dad	b	; Otherwise, add index to array base
	mov	a,m	; Get current item (BC'th item of HL)
	call	chout	; Output
	jmp	inner	; Next array 
azero:	mvi	a,13	; Print newline	
	call	chout
	mvi	a,10
	call	chout
	inr	c	; Increment index (we're only using the low byte)
	mvi	a,Alen	; Is it equal to the length?
	cmp	c
	jnz	outer	; If not, get next item from all the arrays.
	ret		
	;;;	Print character in A, saving all registers.
	;;;	This code uses CP/M to do it.
chout:	push 	psw	; CP/M destroys all registers
	push	b	; Push them all to the stack
	push	d
	push	h
	mvi	c,2	; 2 = print character syscall
	mov	e,a
	call	5
	pop	h	; Restore registers
	pop	d
	pop	b
	pop	psw
	ret
	;;;	Arrays
A1:	db	'a','b','c'
A2:	db	'A','B','C'
A3:	db	'1','2','3'
Alen:	equ	$-A3
	;;;	Zero-terminated array-of-arrays
As:	dw	A1,A2,A3,0

không có sự lộn xộn do xử lý một số lượng bộ sưu tập khác nhau.

	org	100h
	lxi	b,0	; Let (B)C be the array index
outer:	lxi	d,As	; Use DE to walk the array-of-arrays
inner:	xchg		; Swap DE and HL (array-of-array pointer into HL)
	mov	e,m	; Load low byte of array pointer into E
	inx	h
	mov	d,m	; Load high byte of array pointer into D 
	inx	h
	xchg		; Array base in HL, array-of-array pointer in DE
	mov	a,h	; Is HL 0?
	ora	l
	jz	azero	; If so, we are done.
	dad	b	; Otherwise, add index to array base
	mov	a,m	; Get current item (BC'th item of HL)
	call	chout	; Output
	jmp	inner	; Next array 
azero:	mvi	a,13	; Print newline	
	call	chout
	mvi	a,10
	call	chout
	inr	c	; Increment index (we're only using the low byte)
	mvi	a,Alen	; Is it equal to the length?
	cmp	c
	jnz	outer	; If not, get next item from all the arrays.
	ret		
	;;;	Print character in A, saving all registers.
	;;;	This code uses CP/M to do it.
chout:	push 	psw	; CP/M destroys all registers
	push	b	; Push them all to the stack
	push	d
	push	h
	mvi	c,2	; 2 = print character syscall
	mov	e,a
	call	5
	pop	h	; Restore registers
	pop	d
	pop	b
	pop	psw
	ret
	;;;	Arrays
A1:	db	'a','b','c'
A2:	db	'A','B','C'
A3:	db	'1','2','3'
Alen:	equ	$-A3
	;;;	Zero-terminated array-of-arrays
As:	dw	A1,A2,A3,0

(Điều này sẽ dừng lại khi kết thúc bộ sưu tập ngắn nhất.)

EchoLisp[edit][edit]

	org	100h
	lxi	b,0	; Let (B)C be the array index
outer:	lxi	d,As	; Use DE to walk the array-of-arrays
inner:	xchg		; Swap DE and HL (array-of-array pointer into HL)
	mov	e,m	; Load low byte of array pointer into E
	inx	h
	mov	d,m	; Load high byte of array pointer into D 
	inx	h
	xchg		; Array base in HL, array-of-array pointer in DE
	mov	a,h	; Is HL 0?
	ora	l
	jz	azero	; If so, we are done.
	dad	b	; Otherwise, add index to array base
	mov	a,m	; Get current item (BC'th item of HL)
	call	chout	; Output
	jmp	inner	; Next array 
azero:	mvi	a,13	; Print newline	
	call	chout
	mvi	a,10
	call	chout
	inr	c	; Increment index (we're only using the low byte)
	mvi	a,Alen	; Is it equal to the length?
	cmp	c
	jnz	outer	; If not, get next item from all the arrays.
	ret		
	;;;	Print character in A, saving all registers.
	;;;	This code uses CP/M to do it.
chout:	push 	psw	; CP/M destroys all registers
	push	b	; Push them all to the stack
	push	d
	push	h
	mvi	c,2	; 2 = print character syscall
	mov	e,a
	call	5
	pop	h	; Restore registers
	pop	d
	pop	b
	pop	psw
	ret
	;;;	Arrays
A1:	db	'a','b','c'
A2:	db	'A','B','C'
A3:	db	'1','2','3'
Alen:	equ	$-A3
	;;;	Zero-terminated array-of-arrays
As:	dw	A1,A2,A3,0

Ecstasy[edit][edit]

	org	100h
	lxi	b,0	; Let (B)C be the array index
outer:	lxi	d,As	; Use DE to walk the array-of-arrays
inner:	xchg		; Swap DE and HL (array-of-array pointer into HL)
	mov	e,m	; Load low byte of array pointer into E
	inx	h
	mov	d,m	; Load high byte of array pointer into D 
	inx	h
	xchg		; Array base in HL, array-of-array pointer in DE
	mov	a,h	; Is HL 0?
	ora	l
	jz	azero	; If so, we are done.
	dad	b	; Otherwise, add index to array base
	mov	a,m	; Get current item (BC'th item of HL)
	call	chout	; Output
	jmp	inner	; Next array 
azero:	mvi	a,13	; Print newline	
	call	chout
	mvi	a,10
	call	chout
	inr	c	; Increment index (we're only using the low byte)
	mvi	a,Alen	; Is it equal to the length?
	cmp	c
	jnz	outer	; If not, get next item from all the arrays.
	ret		
	;;;	Print character in A, saving all registers.
	;;;	This code uses CP/M to do it.
chout:	push 	psw	; CP/M destroys all registers
	push	b	; Push them all to the stack
	push	d
	push	h
	mvi	c,2	; 2 = print character syscall
	mov	e,a
	call	5
	pop	h	; Restore registers
	pop	d
	pop	b
	pop	psw
	ret
	;;;	Arrays
A1:	db	'a','b','c'
A2:	db	'A','B','C'
A3:	db	'1','2','3'
Alen:	equ	$-A3
	;;;	Zero-terminated array-of-arrays
As:	dw	A1,A2,A3,0

Đầu ra:

	org	100h
	lxi	b,0	; Let (B)C be the array index
outer:	lxi	d,As	; Use DE to walk the array-of-arrays
inner:	xchg		; Swap DE and HL (array-of-array pointer into HL)
	mov	e,m	; Load low byte of array pointer into E
	inx	h
	mov	d,m	; Load high byte of array pointer into D 
	inx	h
	xchg		; Array base in HL, array-of-array pointer in DE
	mov	a,h	; Is HL 0?
	ora	l
	jz	azero	; If so, we are done.
	dad	b	; Otherwise, add index to array base
	mov	a,m	; Get current item (BC'th item of HL)
	call	chout	; Output
	jmp	inner	; Next array 
azero:	mvi	a,13	; Print newline	
	call	chout
	mvi	a,10
	call	chout
	inr	c	; Increment index (we're only using the low byte)
	mvi	a,Alen	; Is it equal to the length?
	cmp	c
	jnz	outer	; If not, get next item from all the arrays.
	ret		
	;;;	Print character in A, saving all registers.
	;;;	This code uses CP/M to do it.
chout:	push 	psw	; CP/M destroys all registers
	push	b	; Push them all to the stack
	push	d
	push	h
	mvi	c,2	; 2 = print character syscall
	mov	e,a
	call	5
	pop	h	; Restore registers
	pop	d
	pop	b
	pop	psw
	ret
	;;;	Arrays
A1:	db	'a','b','c'
A2:	db	'A','B','C'
A3:	db	'1','2','3'
Alen:	equ	$-A3
	;;;	Zero-terminated array-of-arrays
As:	dw	A1,A2,A3,0

Efene[edit][edit]

	org	100h
	lxi	b,0	; Let (B)C be the array index
outer:	lxi	d,As	; Use DE to walk the array-of-arrays
inner:	xchg		; Swap DE and HL (array-of-array pointer into HL)
	mov	e,m	; Load low byte of array pointer into E
	inx	h
	mov	d,m	; Load high byte of array pointer into D 
	inx	h
	xchg		; Array base in HL, array-of-array pointer in DE
	mov	a,h	; Is HL 0?
	ora	l
	jz	azero	; If so, we are done.
	dad	b	; Otherwise, add index to array base
	mov	a,m	; Get current item (BC'th item of HL)
	call	chout	; Output
	jmp	inner	; Next array 
azero:	mvi	a,13	; Print newline	
	call	chout
	mvi	a,10
	call	chout
	inr	c	; Increment index (we're only using the low byte)
	mvi	a,Alen	; Is it equal to the length?
	cmp	c
	jnz	outer	; If not, get next item from all the arrays.
	ret		
	;;;	Print character in A, saving all registers.
	;;;	This code uses CP/M to do it.
chout:	push 	psw	; CP/M destroys all registers
	push	b	; Push them all to the stack
	push	d
	push	h
	mvi	c,2	; 2 = print character syscall
	mov	e,a
	call	5
	pop	h	; Restore registers
	pop	d
	pop	b
	pop	psw
	ret
	;;;	Arrays
A1:	db	'a','b','c'
A2:	db	'A','B','C'
A3:	db	'1','2','3'
Alen:	equ	$-A3
	;;;	Zero-terminated array-of-arrays
As:	dw	A1,A2,A3,0

Nếu các danh sách không phải là cùng một độ dài, một lỗi được ném.

Eiffel[edit][edit]

	org	100h
	lxi	b,0	; Let (B)C be the array index
outer:	lxi	d,As	; Use DE to walk the array-of-arrays
inner:	xchg		; Swap DE and HL (array-of-array pointer into HL)
	mov	e,m	; Load low byte of array pointer into E
	inx	h
	mov	d,m	; Load high byte of array pointer into D 
	inx	h
	xchg		; Array base in HL, array-of-array pointer in DE
	mov	a,h	; Is HL 0?
	ora	l
	jz	azero	; If so, we are done.
	dad	b	; Otherwise, add index to array base
	mov	a,m	; Get current item (BC'th item of HL)
	call	chout	; Output
	jmp	inner	; Next array 
azero:	mvi	a,13	; Print newline	
	call	chout
	mvi	a,10
	call	chout
	inr	c	; Increment index (we're only using the low byte)
	mvi	a,Alen	; Is it equal to the length?
	cmp	c
	jnz	outer	; If not, get next item from all the arrays.
	ret		
	;;;	Print character in A, saving all registers.
	;;;	This code uses CP/M to do it.
chout:	push 	psw	; CP/M destroys all registers
	push	b	; Push them all to the stack
	push	d
	push	h
	mvi	c,2	; 2 = print character syscall
	mov	e,a
	call	5
	pop	h	; Restore registers
	pop	d
	pop	b
	pop	psw
	ret
	;;;	Arrays
A1:	db	'a','b','c'
A2:	db	'A','B','C'
A3:	db	'1','2','3'
Alen:	equ	$-A3
	;;;	Zero-terminated array-of-arrays
As:	dw	A1,A2,A3,0

aa1

BB2

CC3

Explanation[edit][edit]

Khẳng định 'yêu cầu' thiết kế theo hợp đồng là một tuyên bố về tính chính xác của phần mềm. Nó nói rằng tất cả các mục trong `a_array 'phải có số lượng> 0 (không trống của loại giới hạn).

Nếu bạn kiểm tra 'input_data', bạn sẽ thấy rằng Bộ sưu tập 1 không chỉ là "ABC", mà là "ABCDE" (5 mục phần tử ký tự trong một chuỗi giới hạn). Điều tương tự cũng đúng với mảng số cuối cùng, có 4 số nguyên. Điều này được thực hiện để chứng minh rằng mã 'ví dụ' đủ mạnh để lấy các biến thể trong các đầu vào về số lượng mục.

Vòng lặp ⟳ ¦ ¦ ¦ (tượng trưng) đầu tiên tìm kiếm số lượng của bộ sưu tập nhỏ nhất (phút). Trong trường hợp này, mục giữa (#2) chỉ có 3 phần tử, vì vậy thói quen này sẽ chỉ xử lý 3 phần tử đầu tiên của mỗi bộ sưu tập trong mảng chứa.

Tiếp theo, chúng tôi tạo chuỗi đầu ra trong 'result'.

Cuối cùng, vòng lặp ⟳ ¦ ¦ (tượng trưng) cuối cùng có một vòng lặp lồng nhau. Vòng ngoài tính đếm các phần tử (1-3) và vòng lặp bên trong của các bộ sưu tập chứa, thêm phần tử thứ J của bộ sưu tập thứ i. Điều này lặp lại cho đến khi tất cả `j 'đã cạn kiệt cho tất cả' i '.

Ela[edit][edit]

aA1
bB2
cC3

Mã trên có thể được viết ngắn hơn. Đầu tiên không có nhu cầu trong danh sách ngay khi các chuỗi ở ELA có thể được coi là danh sách. Ngoài ra, thay vì LabMDA rõ ràng, người ta có thể sử dụng ứng dụng một phần và toán tử thành phần tiêu chuẩn:

aA1
bB2
cC3

Elena[edit][edit]

Elena 5.0 & nbsp;:

aA1
bB2
cC3

Sử dụng tiện ích mở rộng Zipby:

aA1
bB2
cC3

aA1
bB2
cC3

Elixir[edit][edit]

Danh sách chuỗi:

aA1
bB2
cC3

char_list:

aA1
bB2
cC3

Khi độ dài của danh sách khác nhau:

aA1
bB2
cC3

Việc kết thúc zipping ngay khi bất kỳ sự phản đối nào hoàn thành.

Erlang[edit][edit]

Tùy chọn ngắn nhất:

aA1
bB2
cC3

Tuy nhiên, vì mọi biểu thức trong Erlang phải trả lại một cái gì đó, in văn bản trả về 'ok'. Do đó, một danh sách có nhiều 'OK như có những dòng được in sẽ được tạo ra. Cách làm sạch kỹ thuật nhất về mặt kỹ thuật sẽ là với danh sách: Foreach/2, cũng đảm bảo thứ tự đánh giá:

aA1
bB2
cC3

Nếu các danh sách không phải là cùng một độ dài, một lỗi được ném.

Euphoria[edit][edit]

Có rất nhiều cách để làm điều này. Tất cả bọn họ đều dựa vào những chuỗi thực sự

1,0
2,1
3,2
5,3
(...)

Nếu tất cả chúng là "chuỗi", thì khá dễ dàng:

1,0
2,1
3,2
5,3
(...)

Nếu không, và chuỗi khác được biết là chỉ chứa các số nguyên:

1,0
2,1
3,2
5,3
(...)

Một giải pháp chung cho bất kỳ chuỗi ký tự hoặc số tùy ý nào có thể có một chút phức tạp. Điều này là do cách các chuỗi được lưu trữ và in ra. Một câu trả lời có thể là như sau, nếu bạn biết rằng chỉ sử dụng các ký tự chữ và số:

1,0
2,1
3,2
5,3
(...)

Giống như trong Java, sử dụng các trích dẫn đơn xung quanh một ký tự cung cấp cho bạn "giá trị char" của nó. Tuy nhiên, trong Euphoria, chỉ đơn giản là mã của nhân vật trong ASCII.

Với cả ba giải pháp trên, nếu bất kỳ chuỗi nào nhỏ hơn

1,0
2,1
3,2
5,3
(...)

F#[edit][edit]

1,0
2,1
3,2
5,3
(...)

Khi một chuỗi bị cạn kiệt, bất kỳ yếu tố còn lại trong các chuỗi khác đều bị bỏ qua.

Factor[edit][edit]

1,0
2,1
3,2
5,3
(...)

Fantom[edit][edit]

Điều này sẽ dừng lại khi nó đến cuối danh sách ngắn nhất.

1,0
2,1
3,2
5,3
(...)

Fermat[edit][edit]

1,0
2,1
3,2
5,3
(...)

aa1

BB2

CC3

Forth[edit][edit]

1,0
2,1
3,2
5,3
(...)

Fortran[edit][edit]

1,0
2,1
3,2
5,3
(...)

Nếu các mảng có độ dài khác nhau (giả sử, Array NS không có phần tử thứ ba), thì khi lượt của nó xuất hiện, đơn vị lưu trữ tiếp theo cùng với phần tử thứ hai sẽ được truy cập, nội dung của nó được hiểu là một số nguyên và giá trị thập phân của nó được in. .. Nếu tuy nhiên, kiểm tra ràng buộc mảng được kích hoạt (hoặc có sơ đồ bảo vệ truy cập bộ nhớ sẽ phát hiện điều này), một tính năng không có sẵn thông qua nhiều trình biên dịch và không phải là mặc định cho phần còn lại, sau đó sẽ được phát hiện lỗi và chạy chấm dứt, có thể với một thông điệp có phần hữu ích.

Nếu thay vì đọc hành động đã được lưu trữ một giá trị vào mảng, thì trong trường hợp không kiểm tra ràng buộc, thiệt hại tùy ý sẽ được thực hiện (để mã hoặc dữ liệu) có thể dẫn đến điều gì đó không ổn. Và nếu bạn may mắn, nó sẽ xảy ra nhanh chóng.

FreeBASIC[edit][edit]

1,0
2,1
3,2
5,3
(...)

1,0
2,1
3,2
5,3
(...)

Frink[edit][edit]

1,0
2,1
3,2
5,3
(...)

FunL[edit][edit]

1,0
2,1
3,2
5,3
(...)

aA1
bB2
cC3

Gambas[edit][edit]

Nhấp vào liên kết này để chạy mã này

1,0
2,1
3,2
5,3
(...)

Đầu ra:

aA1
bB2
cC3

GAP[edit][edit]

1,0
2,1
3,2
5,3
(...)

Go[edit][edit]

"Mệnh đề phạm vi" của một câu lệnh chỉ nhìn vào một giá trị có thể đi được duy nhất (mảng, lát cắt, v.v.). Để truy cập ba song song, chúng phải được lập chỉ mục rõ ràng.

Nếu

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

1,0
2,1
3,2
5,3
(...)

Golfscript[edit][edit]

1,0
2,1
3,2
5,3
(...)

Nếu có các mảng có kích thước khác nhau, thì ngắn hơn được coi là mảng "null-bong".

Groovy[edit][edit]

Dung dịch:

1,0
2,1
3,2
5,3
(...)

Bài kiểm tra:

1,0
2,1
3,2
5,3
(...)

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Harbour[edit][edit]

Sử dụng cho mỗi ... tuyên bố tiếp theo

1,0
2,1
3,2
5,3
(...)

Đầu ra:

1,0
2,1
3,2
5,3
(...)

"Mệnh đề phạm vi" của một câu lệnh chỉ nhìn vào một giá trị có thể đi được duy nhất (mảng, lát cắt, v.v.). Để truy cập ba song song, chúng phải được lập chỉ mục rõ ràng.

Haskell[edit][edit]

Nếu

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

1,0
2,1
3,2
5,3
(...)

Nếu có các mảng có kích thước khác nhau, thì ngắn hơn được coi là mảng "null-bong".

Dung dịch:

1,0
2,1
3,2
5,3
(...)

Bài kiểm tra:

1,0
2,1
3,2
5,3
(...)

Sử dụng cho mỗi ... tuyên bố tiếp theo

Nếu các mảng không có độ dài bằng nhau, việc lặp lại sẽ dừng sau khi mục cuối cùng của mảng nhỏ hơn đã được xử lý; Bất kỳ mục bổ sung nào của các mảng dài hơn đều bị bỏ qua (hoặc nói cách khác, bộ đếm lặp không bao giờ vượt quá độ dài của mảng nhỏ hơn, do đó ngăn chặn lỗi 'ra khỏi phạm vi phụ').

1,0
2,1
3,2
5,3
(...)

Haxe[edit][edit]

1,0
2,1
3,2
5,3
(...)

HicEst[edit][edit]

1,0
2,1
3,2
5,3
(...)

Biểu tượng và Unicon [Chỉnh sửa][edit]

Giải pháp đầu tiên sử dụng các biểu thức đồng để tạo ra đánh giá song song.

1,0
2,1
3,2
5,3
(...)

Giải pháp thứ hai giống như các ngôn ngữ thủ tục khác và cũng xử lý các độ dài danh sách không đồng đều.

1,0
2,1
3,2
5,3
(...)

[http://www.cs.arizona.edu/icon/l Library/procs/numbers.htm sử dụng tối đa từ các số]

J[edit][edit]

Cho các mảng các loại khác nhau:

1,0
2,1
3,2
5,3
(...)

Cách tiếp cận này hoạt động bằng cách thể hiện các chữ số là ký tự.

Trong đó các mảng đều cùng loại (tất cả số hoặc tất cả chuỗi):

1,0
2,1
3,2
5,3
(...)

Cả hai triển khai này đều từ chối các mảng với độ dài mâu thuẫn.

Các tùy chọn khác bao gồm:

1,0
2,1
3,2
5,3
(...)

1,0
2,1
3,2
5,3
(...)

Các mảng ngắn thực hiện này với không gian.

Hoặc:

1,0
2,1
3,2
5,3
(...)

Việc triển khai này đặt từng mục từ mỗi danh sách ban đầu vào một hộp và tạo thành một mảng các hộp. . Mảng bằng cách cung cấp các hộp trống để biểu diễn các yếu tố bị thiếu. .

Java[edit][edit]

1,0
2,1
3,2
5,3
(...)

JavaScript[edit][edit]

Imperative[edit][edit]

Điều này lặp lại các chỉ số của mảng đầu tiên và sử dụng nó để lập chỉ mục vào các chỉ số khác.

1,0
2,1
3,2
5,3
(...)

Nếu các mảng B hoặc C quá "ngắn", bạn sẽ thấy chuỗi "không xác định" xuất hiện trong đầu ra.

Ngoài ra, chúng ta có thể làm tổ một vài cuộc gọi đến .foreach (): một cho mảng ba mảng và một cho mỗi trong ba vị trí chỉ số:.forEach(): one for the array of three arrays, and one for each of the three index positions:

1,0
2,1
3,2
5,3
(...)

Thành phần chức năng [Chỉnh sửa][edit]

ES5[edit][edit]

Các tùy chọn chức năng bao gồm gấp lại trên một mảng các mảng với mảng tích hợp.Reduce (), sử dụng hàm zipwith () của arity phù hợp hoặc ánh xạ qua đầu ra của hàm zip () đầu ra của một hàm zip ().Array.reduce(), using a zipWith() function of suitable arity, or mapping over the output of a generic (any arity) zip() function.

.

Giảm / gấp:

1,0
2,1
3,2
5,3
(...)

Một zipwith cố định:

1,0
2,1
3,2
5,3
(...)

Hoặc chúng ta có thể viết một ziplistswith chung áp dụng một số danh sách Overs hàm được cung cấp có nguồn gốc từ các thành viên thứ n của một danh sách danh sách (độ dài bằng nhau) tùy ý.zipListsWith applying some supplied function overs lists derived from the nth members of an arbitrary list of (equal-length) lists.

1,0
2,1
3,2
5,3
(...)

ES6[edit][edit]

Bằng cách chuyển vị:

1,0
2,1
3,2
5,3
(...)

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

jq[edit][edit]

Giải pháp sau đây dựa trên giả định rằng tất cả các mảng có thể được trình bày dưới dạng một mảng mảng. Điều này cho phép bất kỳ số lượng mảng được xử lý.

Cụ thể, ZIP/0 mong đợi một mảng từ 0 hoặc nhiều mảng trở thành đầu vào của nó. Mảng đầu tiên xác định số lượng mục trong đầu ra; null được sử dụng để đệm.

1,0
2,1
3,2
5,3
(...)

Ví dụ 1:

1,0
2,1
3,2
5,3
(...)

1,0
2,1
3,2
5,3
(...)

Để có được đầu ra nhỏ gọn được sử dụng trong mô tả nhiệm vụ, chúng ta có thể lọc kết quả thông qua chức năng "in đẹp":

1,0
2,1
3,2
5,3
(...)

Ví dụ 2:

1,0
2,1
3,2
5,3
(...)

1,0
2,1
3,2
5,3
(...)

Như đã đề cập, định nghĩa trên của các đặc quyền zip/0 đầu tiên

1,0
2,1
3,2
5,3
(...)

và nếu các mảng tiếp theo có độ dài khác nhau, NULL được sử dụng làm

1,0
2,1
3,2
5,3
(...)

Do đó:

1,0
2,1
3,2
5,3
(...)

Sản xuất:

1,0
2,1
3,2
5,3
(...)

Xử lý đầu vào Jagged Một cách tiếp cận thay thế sẽ được sử dụng một biến thể zip/0 mà tất cả các mảng đều ngắn hơn so với dài nhất với nulls. Đây là một biến thể như vậy: An alternative approach would be use a variant of zip/0 that pads all arrays shorter than the longest with nulls. Here is such a variant:

1,0
2,1
3,2
5,3
(...)

Jsish[edit][edit]

1,0
2,1
3,2
5,3
(...)

1,0
2,1
3,2
5,3
(...)

Julia[edit][edit]

Với chức năng bậc cao hơn::

1,0
2,1
3,2
5,3
(...)

Với một vòng lặp::

1,0
2,1
3,2
5,3
(...)

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

K[edit][edit]

1,0
2,1
3,2
5,3
(...)

1,0
2,1
3,2
5,3
(...)

Nếu độ dài của các mảng là khác nhau, thì k croaks với "lỗi chiều dài".

Sau đây là một cách tiếp cận chung hơn trong đó

Tính độ dài tối thiểu của các mảng và được sử dụng để lập chỉ mục các phần tử đầu tiên trong mỗi mảng.

1,0
2,1
3,2
5,3
(...)

1,0
2,1
3,2
5,3
(...)

Nếu các mảng thuộc loại khác nhau, thì các mảng phải được chuyển đổi thành chuỗi.

1,0
2,1
3,2
5,3
(...)

Kotlin[edit][edit]

1,0
2,1
3,2
5,3
(...)

1,0
2,1
3,2
5,3
(...)

Lambdatalk[edit][edit]

1,0
2,1
3,2
5,3
(...)

LFE[edit][edit]

1,0
2,1
3,2
5,3
(...)

Nếu bất kỳ danh sách dữ liệu nào khác nhau về kích thước khác, kết quả sẽ in ra danh sách dữ liệu ngắn nhất và sau đó nêu lỗi

    aA1
    bB2
    cC3

Erlang, và do đó LFE, có

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

Liberty Basic [Chỉnh sửa][edit]

1,0
2,1
3,2
5,3
(...)

Lisaac[edit][edit]

1,0
2,1
3,2
5,3
(...)

LiveCode[edit][edit]

Mảng

1,0
2,1
3,2
5,3
(...)

Xử lý "Danh sách"

1,0
2,1
3,2
5,3
(...)

Đầu ra - Cả hai hành xử tương tự cho bài tập này.

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Khi có ít phần tử hơn phần đầu tiên (hoặc bất kỳ vòng lặp dựa trên), LiveCode sẽ thêm giá trị "trống". Nếu chúng ta thêm "D" vào Lowa và 4 vào NUM, chúng ta sẽ nhận được những điều sau:

1,0
2,1
3,2
5,3
(...)

Logo[edit][edit]

1,0
2,1
3,2
5,3
(...)

Lua[edit][edit]

Điều này có thể được thực hiện với một vòng lặp đơn giản:

1,0
2,1
3,2
5,3
(...)

Nhưng nó có thể là sự khai sáng hơn (và phù hợp với tinh thần của thử thách) để sử dụng chung chung cho:

1,0
2,1
3,2
5,3
(...)

Maple[edit][edit]

1,0
2,1
3,2
5,3
(...)

aA1
bB2
cC3

Ngôn ngữ Mathicala/Wolfram [Chỉnh sửa][edit]

Điều này có thể được thực hiện với một chức năng tích hợp:

1,0
2,1
3,2
5,3
(...)

Tất cả các đối số phải là danh sách có cùng độ dài.

Mercury[edit][edit]

1,0
2,1
3,2
5,3
(...)

Gia đình thủ tục Foldl_correspesing đều ném một phần mềm_error/1 ngoại lệ nếu độ dài của danh sách không giống nhau.

Modula-3[edit][edit]

1,0
2,1
3,2
5,3
(...)

MUMPS[edit][edit]

Các mảnh của phiên bản chuỗi

1,0
2,1
3,2
5,3
(...)

Khi không có đủ các phần tử, một chuỗi null sẽ được trả về từ hàm mảnh $.

1,0
2,1
3,2
5,3
(...)

Phiên bản mảng cục bộ

1,0
2,1
3,2
5,3
(...)

Dòng nhận xét sẽ gây ra lỗi khi thử

1,0
2,1
3,2
5,3
(...)

Cú pháp tương tự này được sử dụng cho các toàn cầu (các biến vĩnh viễn, có một cái chăm sóc "^" là ký tự đầu tiên).

1,0
2,1
3,2
5,3
(...)

Nanoquery[edit][edit]

Bản dịch của: Java: Java

1,0
2,1
3,2
5,3
(...)

Nemerle[edit][edit]

Nó "cảm thấy" tốt hơn khi sử dụng zip () cho điều này, thật không may, zip () tích hợp chỉ mất hai danh sách.

1,0
2,1
3,2
5,3
(...)

Xen kẽ:

Bản dịch của: C#: C#

1,0
2,1
3,2
5,3
(...)

NetRexx[edit][edit]

1,0
2,1
3,2
5,3
(...)

1,0
2,1
3,2
5,3
(...)

NewLISP[edit][edit]

1,0
2,1
3,2
5,3
(...)

Nim[edit][edit]

1,0
2,1
3,2
5,3
(...)

NS-HUBASIC[edit][edit]

1,0
2,1
3,2
5,3
(...)

Oberon-2[edit][edit]

Hoạt động với OO2C phiên bản 2

1,0
2,1
3,2
5,3
(...)

Output:

aA1
bB2
cC3

Objeck[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Nếu các mảng có độ dài khác nhau, thì một lỗi ngoài giới hạn sẽ được nêu ra.

OCaml[edit][edit]

Một giải pháp ngay lập tức:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Một giải pháp chung hơn có thể là sử dụng một chức năng lặp đi lặp lại trong danh sách các mảng:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Chức năng này làm tăng ngoại lệ không hợp lệ

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

và có chữ ký này:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Cách sử dụng nó với các mảng A1, A2 và A3 được xác định trước:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Oforth[edit][edit]

Nếu các mảng không có cùng kích thước, Zipall sẽ giảm xuống kích thước tối thiểu

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

aA1
bB2
cC3

ooRexx[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Oz[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Vòng lặp sẽ dừng lại khi danh sách ngắn nhất cạn kiệt.

PARI/GP[edit][edit]

Phiên bản này dừng lại khi vectơ ngắn nhất cạn kiệt.

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Phiên bản này in trống khi một vector cạn kiệt.

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Pascal[edit][edit]

Xem Delphi

Perl[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Việc triển khai này sẽ ngừng sản xuất các mặt hàng khi mảng ngắn nhất kết thúc.

Phix[edit][edit]

Giả sử A và B là chuỗi và C là một chuỗi số nguyên. Nếu các đối số không phải là cùng một độ dài, các nỗ lực truy xuất các phần tử không tồn tại có thể kích hoạt lỗi thời gian chạy nghiêm trọng, phải không cho Min (). Trong Print3, khá rõ ràng, chúng tôi chỉ trích xuất đến độ dài ngắn nhất. Thói quen tích hợp () thường trình có thể thực hiện một tác vụ tương tự: Tôi đã cung cấp một độ lệch không gian và thay thế mảng thứ 3 bằng một chuỗi để đảm bảo chúng tôi lấy lại chuỗi và mở rộng nó để hiển thị cách sử dụng giá trị mặc định đó cho các mục nhập ra khỏi đầu của hai mảng đầu tiên.
If the arguments were not all the same length, attempts to retrieve non-existent elements could trigger a fatal run-time error, were it not for the min(). In print3, fairly obviously, we only extract up to the shortest length. The builtin columnize() routine can perform a similar task: I have provided a space defval and replaced the 3rd array with a string to ensure we get strings back, and extended it to show how columnize uses that default value for missing entries off the end of the first two arrays.

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Phixmonti[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

PHP[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Việc triển khai này ném một ngoại lệ nếu các mảng không phải là cùng một độ dài.

Picat[edit][edit]

PICAT có một

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

Đối với nhiệm vụ này, một vòng lặp foreach và danh sách comprenhension được hiển thị.

Nếu các danh sách/mảng có độ dài không đồng đều, thì các phần tử trong các mảng dài hơn bị bỏ qua.

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

PicoLisp[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Độ dài của danh sách đối số đầu tiên kiểm soát hoạt động. Nếu các danh sách tiếp theo dài hơn, các giá trị còn lại của chúng bị bỏ qua. Nếu chúng ngắn hơn, NIL được chuyển đến chức năng.

Pike[edit][edit]

Có thể được thực hiện với cho, nhưng các foreach bao gồm bộ đếm chỉ mục tránh các lỗi thông thường

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

aA1
bB2
cC3

PL/I[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

PostScript[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

PowerBASIC[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

PowerShell[edit][edit]

Một chức năng 'zip' giá rẻ và đáng yêu:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

aA1
bB2
cC3

Prolog[edit][edit]

Hoạt động với SWI-Prolog

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

PureBasic[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Nếu chúng có độ dài khác nhau, có hai trường hợp: A () là một trường hợp ngắn nhất: chỉ các phần tử lên đến chỉ số tối đa của A () Có thể hoạt động vì có một số "không gian trống" sau khi kết thúc bộ nhớ mảng được gán. Ví dụ: nếu A có kích thước 4, dòng DD4 cũng sẽ được in. Kích thước 20 dẫn đến một sự cố, điều này là do Redim trở nên chậm nếu mọi khi có sự thay đổi đối với kích thước mảng bộ nhớ mới phải được phân bổ.
a() is the shortest one: Only elements up to maximum index of a() are printed
a() is bigger than another one: if exceeding index to much, program crashes,
else it may work because there is some "free space" after end of assigned array memory.
For example if a has size 4, line dD4 will also be printed. size 20 leads to an crash
This is because ReDim becomes slow if everytime there is a change to array size new memory has to be allocated.

Python[edit][edit]

Sử dụng zip ():

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Nếu danh sách có độ dài khác nhau, zip () sẽ dừng sau phần ngắn nhất.

Sử dụng bản đồ ():

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Nếu danh sách có độ dài khác nhau, bản đồ () trong Python 2.x giả vờ rằng các danh sách ngắn hơn được mở rộng với không có mục nào; Bản đồ () trong Python 3.x dừng sau khi ngắn nhất.

Sử dụng itertools.imap () (Python 2.x):

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Nếu danh sách là độ dài khác nhau, imap () dừng sau khi ngắn nhất bị cạn kiệt.

Python 3.x có zip_longest, lấp đầy các lần lặp ngắn hơn với đối số fillvalue của nó mặc định là không có (tương tự như hành vi của map () trong python 2.x):

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

(Tương đương Python 2.x là itertools.izip_longest)

Quackery[edit][edit]

Mã được trình bày ở đây sẽ lặp lại nhiều lần so với số lượng ký tự trong tổ đầu tiên (tức là "ABC" trong ví dụ). Nếu một trong hai tổ còn lại ngắn hơn đầu tiên thì chương trình sẽ báo cáo vấn đề.

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

aA1
bB2
cC3

R[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Điều tương tự như một cuộc gọi chức năng duy nhất. Nhưng ném lỗi nếu các mảng khác nhau về chiều dài.

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Racket[edit][edit]

Cordet cho các vòng lặp có thể lặp qua một số chuỗi tùy ý cùng một lúc:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Vòng lặp dừng ngay khi chuỗi đầu tiên kết thúc - trong trường hợp trên tôi có thể lặp lại mãi mãi nhưng vòng lặp dừng khi chúng tôi đến cuối danh sách/vectơ/chuỗi. (Cùng một giữ cho nhiều container có kích thước khác nhau.)

Raku[edit][edit]

(trước đây là Perl 6)

Làm việc với: Phiên bản Rakudo 2015.12: rakudo version 2015.12

Lưu ý rằng tất cả các công việc sau đây với bất kỳ đối tượng có thể lặp lại, (mảng, danh sách, phạm vi, trình tự; bất cứ điều gì thực hiện vai trò có thể lặp lại), không chỉ là mảng.

Chức năng cơ bản [Chỉnh sửa][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Nhà điều hành

    aA1
    bB2
    cC3

Vì

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

Bao thanh toán kết nối [chỉnh sửa][edit]

Lưu ý rằng chúng ta cũng có thể đưa ra sự kết hợp bằng cách làm cho bộ điều khiển Z áp dụng toán tử ~ nối trên mỗi bộ ba:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Chúng tôi cũng có thể sử dụng chuỗi zip-to với bộ điều khiển giảm:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Chúng tôi cũng có thể viết ra điều đó "tay dài":

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Trả về kết quả chính xác tương tự vì vậy nếu bạn không thoải mái với các toán tử súc tích, bạn có một sự lựa chọn.

Một danh sách và các chỉ số của nó [chỉnh sửa][edit]

Trường hợp phổ biến của việc lặp lại trong danh sách và danh sách các chỉ số của nó có thể được thực hiện bằng cách sử dụng cùng một phương thức:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

hoặc bằng cách sử dụng phương thức

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Lặp lại cho đến khi tất cả kiệt sức [chỉnh sửa][edit]

Nếu bạn có các danh sách có kích thước khác nhau mà bạn muốn lấy giá trị từ mỗi lần lặp, nhưng muốn tiếp tục cho đến khi tất cả các danh sách đã cạn kiệt, chúng tôi có

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Red[edit][edit]

Từ lặp lại đánh giá một khối nhất định! Một số lần được chỉ định và phơi bày giá trị đếm cho khối! được thực hiện. Khi một biến được sử dụng trong một ký hiệu đường dẫn, chúng tôi đặt một đại tràng trước nó. :phản đối

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

REXX[edit][edit]

cùng một mảng kích thước [chỉnh sửa][edit]

Nếu bất kỳ phần tử nào của mảng bị thiếu hoặc đó là một danh sách ngắn, một trống được thay thế để giữ lại độ trung thực thị giác trong đầu ra.

Khi & nbsp; tất cả & nbsp; Các yếu tố trống, sau đó nó biểu thị phần cuối của mảng.

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

đầu ra

aA1
bB2
cC3

Mảng có kích thước khác nhau [Chỉnh sửa][edit]

Trong ví dụ này, hai trong số các mảng được mở rộng (qua ví dụ đầu tiên). Cũng lưu ý rằng Rexx không yêu cầu báo giá xung quanh các số không âm (chúng là tùy chọn).
Also note that REXX doesn't require quotes around non-negative numbers (they're optional).

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

đầu ra

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Mảng có kích thước khác nhau [Chỉnh sửa][edit]

Trong ví dụ này, hai trong số các mảng được mở rộng (qua ví dụ đầu tiên). Cũng lưu ý rằng Rexx không yêu cầu báo giá xung quanh các số không âm (chúng là tùy chọn).

đầu ra

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Mảng có kích thước khác nhau [Chỉnh sửa][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

đầu ra

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Ring[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Ruby[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Mảng có kích thước khác nhau [Chỉnh sửa]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Trong ví dụ này, hai trong số các mảng được mở rộng (qua ví dụ đầu tiên). Cũng lưu ý rằng Rexx không yêu cầu báo giá xung quanh các số không âm (chúng là tùy chọn).

Danh sách có kích thước khác nhau [Chỉnh sửa]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

(a,b,c) (A,B,C) (1,2,3) 56[edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Rust[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Salmon[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Phương pháp thành ngữ cho danh sách [Chỉnh sửa]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Sather[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Scala[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Scheme[edit][edit]

hoặc

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Cả hai vòng này đều in

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Trình lặp tương tự cho vectơ,

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Lưu ý, các danh sách hoặc vectơ phải có cùng độ dài.

Sidef[edit][edit]

Cách đơn giản nhất là bằng cách sử dụng phương thức mảng.zip {}:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

aA1
bB2
cC3

Smalltalk[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Nếu INDEX I không bị ràng buộc, một lỗi thời gian chạy được nêu ra.

Trên thực tế, không cần phải có các đơn đặt hàng thêm như trong ví dụ trên. Ngoài ra, hầu hết các con số nhỏ (tất cả?) Có thể nối các args không chuỗi. Ít nhất là trong ST/X, các tác phẩm sau ¹:
Also, most Smalltalks (all?) can concatenate non-string args¹.
At least in ST/X, the following works ¹:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Một giải pháp khác là sử dụng một điều tra viên đa thu thập, che giấu quyền truy cập phần tử (trong suốt cho các phần tử được lưu trữ bên trong bộ sưu tập):

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

1) Sự kết hợp của các đối tượng số nguyên như được hiển thị ở trên có thể yêu cầu thay đổi trong việc triển khai, dấu phẩy), để gửi "asstring" đến đối số.

ML tiêu chuẩn [Chỉnh sửa][edit]

Mã dưới đây sẽ kết hợp tùy ý nhiều danh sách các chuỗi vào một danh sách duy nhất với độ dài bằng với danh sách ngắn nhất.

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Stata[edit][edit]

Sử dụng một biến chỉ mục.

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Mata[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

SuperCollider[edit][edit]

Sử dụng ba biến và lập chỉ mục (SuperCollider đăng câu lệnh cuối cùng trong bản sao)

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Một cách viết thành ngữ hơn, độc lập với số lượng kích thước:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Hoặc đơn giản hơn:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Tương tự với Lamination (một khái niệm từ APL/J):

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Độc lập với kích thước:

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Swift[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Tailspin[edit][edit]

Lặp lại đơn giản nhất với một "vòng lặp" thông thường sẽ lỗi ở kích thước không đồng đều

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

aA1
bB2
cC3

Một phương thức chuyển vị đơn giản cung cấp cùng một đầu ra và cũng lỗi ở kích thước không đồng đều

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Một chuyển vị phức tạp hơn sử dụng "foreach" phù hợp hơn với đề xuất nhiệm vụ và xử lý các mảng không đều

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Tcl[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

Nếu danh sách có độ dài khác nhau, hướng dẫn sử dụng [1] nói: "Tổng số lần lặp vòng lặp đủ lớn để sử dụng hết tất cả các giá trị từ tất cả các danh sách giá trị. Nếu một danh sách giá trị không chứa đủ các phần tử cho mỗi biến vòng lặp của nó Trong mỗi lần lặp, các giá trị trống được sử dụng cho các phần tử bị thiếu. "

TorqueScript[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

TUSCRIPT[edit][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

TXR[edit][edit]

Ngôn ngữ mẫu [Chỉnh sửa][edit]

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

TXR LISP, sử dụng ________ 400 [Chỉnh sửa][edit]

Ở đây chúng tôi thực sự lặp lại bốn điều: ba chuỗi và một danh sách vô hạn của Newlines. Đầu ra được xây dựng dưới dạng một đối tượng chuỗi cuối cùng được in trong một lần.

    (a,b,c)
    (A,B,C) 
    (1,2,3) 

TXR LISP, sử dụng ________ 401 [Chỉnh sửa][edit]

    aA1
    bB2
    cC3

Dịch thuật của Sơ đồ [Chỉnh sửa][edit]

    aA1
    bB2
    cC3

Dịch logo [Chỉnh sửa][edit]

Dịch: logo: Logo

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

TypeScript[edit][edit]

    aA1
    bB2
    cC3

aA1
bB2
cC3

Unix Shell [Chỉnh sửa][edit]

Với vỏ Bourne, vòng lặp

    aA1
    bB2
    cC3

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

    aA1
    bB2
    cC3

aA1
bB2
cC3

Khi các danh sách có độ dài khác nhau, mã này sử dụng độ dài của danh sách

    aA1
    bB2
    cC3

Và danh sách ngắn hơn cho các chuỗi trống thêm.

Lấy cảm hứng từ ví dụ trước, dưới đây là cách lặp qua hai mảng đồng thời bằng cách sử dụng

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

Some shells have real arrays, so the iteration is much more simple and easy.

    aA1
    bB2
    cC3

aA1
bB2
cC3

    aA1
    bB2
    cC3

Tác phẩm với: ZSH: zsh

    aA1
    bB2
    cC3

C shell [Chỉnh sửa][edit]

Sử dụng chiều dài của mảng a. Các mảng dài hơn bỏ qua các phần tử bổ sung của chúng, nhưng các mảng ngắn hơn buộc shell phải thoát với một lỗi như B: Subscript ra khỏi phạm vi.

    aA1
    bB2
    cC3

Ursa[edit][edit]

Vòng lặp qua nhiều mảng trong một phiên tương tác:

    aA1
    bB2
    cC3

Nếu một trong hai mảng nhỏ hơn (kích thước A), thì một chỉ mục được ném. Điều này có thể được bắt với một khối

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

Ursala[edit][edit]

Tính chuyển vị của danh sách được hình thành của ba danh sách. Nếu chúng có độ dài không đồng đều, một ngoại lệ sẽ xảy ra.

    aA1
    bB2
    cC3

aA1
bB2
cC3

Vala[edit][edit]

    aA1
    bB2
    cC3

VBA[edit][edit]

Làm việc với: VBA Phiên bản VBA Excel 2013: VBA version VBA Excel 2013

    aA1
    bB2
    cC3

aA1
bB2
cC3

VBScript[edit][edit]

    aA1
    bB2
    cC3

aA1
bB2
cC3

Visual Basic .Net [Chỉnh sửa][edit]

Hai triển khai: Một xác định ngắn nhất trong số các mảng và sử dụng một vòng đơn giản cho vòng lặp với các truy cập phần tử cho mỗi mảng một cách riêng biệt; người ta sử dụng enumable.zip (chỉ có thể zip hai chuỗi cùng một lúc) hai lần để tạo 3 bộ. Enumable.zip dừng khi một trong hai nguồn hết các yếu tố, do đó, hành vi của hai triển khai là giống hệt nhau đối với các mảng có độ dài khác nhau.

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

Visual FoxPro [Chỉnh sửa][edit]

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

V (Vlang) [Chỉnh sửa][edit]

    aA1
    bB2
    cC3

Wart[edit][edit]

    aA1
    bB2
    cC3

Wren[edit][edit]

Kịch bản sau đây sẽ hoạt động như mong đợi với độ dài của A1 và A2 ít nhất bằng chiều dài của A3. Nếu không, nó sẽ tạo ra một 'chỉ số ngoài giới hạn'.

    aA1
    bB2
    cC3

aA1
bB2
cC3

Hội đồng x86 [Chỉnh sửa][edit]

    aA1
    bB2
    cC3

XBasic[edit][edit]

    aA1
    bB2
    cC3

XPL0[edit][edit]

    aA1
    bB2
    cC3

aA1
bB2
cC3

Hội đồng Z80 [Chỉnh sửa][edit]

    aA1
    bB2
    cC3

    aA1
    bB2
    cC3

Chương trình chỉ được viết để hiển thị 3 ký tự đầu tiên. Nếu chúng có độ dài khác nhau, các ký tự sai (hoặc các byte ngẫu nhiên bên ngoài chương trình) sẽ được đọc, tùy thuộc vào mảng nào "hết" trước. Ba mảng được xác định với Chỉ thị

L(x, y, z) zip(‘abc’, ‘ABC’, ‘123’)
   print(x‘’y‘’z)

zkl[edit][edit]

    aA1
    bB2
    cC3

hoặc

    aA1
    bB2
    cC3

aA1
bB2
cC3

Zip [with] dừng ở cuối chuỗi ngắn nhất, có nghĩa là nó có thể hoạt động với các chuỗi vô hạn

Zig[edit][edit]

    aA1
    bB2
    cC3

ZX Spectrum Basic [Chỉnh sửa][edit]

    aA1
    bB2
    cC3

Đơn giản hóa

    aA1
    bB2
    cC3

Làm thế nào để lặp qua các yếu tố mảng javascript?

Vòng lặp nào là tốt nhất cho mảng trong JavaScript?

Điều gì xảy ra nếu chúng ta thêm hai mảng trong JavaScript?

Cách đơn giản nhất để lặp qua một mảng là gì?