0521 - kSecventa - Revision history

Flaviu at 20:01, 14 May 2023

2023-05-14T20:01:28Z

← Older revision		Revision as of 20:01, 14 May 2023
Line 72:		Line 72:
	</syntaxhighlight>		</syntaxhighlight>
	== Explicatie Rezolvare ==		== Explicatie Rezolvare ==
	Funcția validate_input ~~primește valorile citite de la tastatură~~ și verifică dacă ~~îndeplinesc restricțiile impuse de problemă~~.		Funcția validate_input(n, k, arr) verifică dacă intrarea este validă și întoarce un rezultat boolean care indică dacă intrarea este validă sau nu. Mai exact, verifică dacă k este mai mic decât n, dacă n este divizibil cu k, iar dacă toate elementele din vectorul arr sunt mai mici sau egale cu 1000.
	Funcția ~~check_sequences primește valorile validate~~ și ~~verifică existența a~~ două secvențe identice în vectorul ~~dat~~.
	~~Se parcurg secvențele~~ de lungime n/k din ~~vector, verificându~~-se dacă ~~au mai fost întâlnite~~.		Funcția find_identical_sequences(n, k, arr) caută și afișează pe ecran două secvențe identice de lungime k din vectorul arr, dacă există. Pentru a face acest lucru, împarte vectorul în sub-secvențe de lungime k, creând o secvență din fiecare sub-secvență și verificând dacă secvența respectivă există deja într-un dicționar. Dacă secvența există deja în dicționar, înseamnă că am găsit două secvențe identice și le afișăm pozițiile. Dacă ajungem la sfârșitul vectorului și nu găsim nicio pereche de secvențe identice, afișăm mesajul "NU".
	Dacă ~~se găsește o secvență identică~~, ~~se afișează numerele de ordine ale celor~~ două secvențe și ~~se returnează din funcție~~.
	Dacă nu ~~se găsește~~ nicio ~~secvență identică~~, ~~se afișează~~ mesajul "NU".		Funcția principală if __name__ == "__main__" citește datele de intrare și, dacă acestea sunt valide, afișează mesajul "Datele sunt introduse corect." și apelează funcția find_identical_sequences(n, k, arr) pentru a căuta secvențele identice. Dacă datele de intrare nu sunt valide, se afișează mesajul "Datele nu corespund restricțiilor impuse."
	~~Dacă datele nu respectă restricțiile, se afișează mesajul corespunzător și se returnează din funcție.~~
	Funcția ~~check_sequences este apelată în cadrul blocului~~ if __name__ == "__main__"~~, unde se citesc~~ datele de intrare."~~__main__"~~, ~~unde se citesc~~ datele de intrare.

Monica Dragos: /* Date de ieșire */

2023-05-14T19:58:03Z

Date de ieșire

← Older revision		Revision as of 19:58, 14 May 2023
Line 7:		Line 7:
	== Date de ieșire ==		== Date de ieșire ==
	Dacă datele sunt introduse corect, pe ecran se va afișa:		Dacă datele sunt introduse corect, pe ecran se va afișa:
	'''"Datele sunt introduse corect."''', apoi pe un rând nou '''se va afișa pe ecran numerele i j, i < j reprezentând numerele de ordine a două secvențe identice, dacă există două astfel de secvențe, sau mesajul NU, dacă nu există două astfel de secvențe, dacă există mai multe perechi de secvențe identice se vor considera cele cu numerele de ordine minime.''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''		'''"Datele sunt introduse corect."''', apoi pe un rând nou '''se va afișa pe ecran numerele i j, i < j reprezentând numerele de ordine a două secvențe identice, dacă există două astfel de secvențe, sau mesajul NU, dacă nu există două astfel de secvențe, dacă există mai multe perechi de secvențe identice se vor considera cele cu numerele de ordine minime''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''

	== Restricţii şi precizări ==		== Restricţii şi precizări ==

Monica Dragos: /* Date de ieșire */

2023-05-14T19:57:39Z

Date de ieșire

← Older revision		Revision as of 19:57, 14 May 2023
Line 7:		Line 7:
	== Date de ieșire ==		== Date de ieșire ==
	Dacă datele sunt introduse corect, pe ecran se va afișa:		Dacă datele sunt introduse corect, pe ecran se va afișa:
	'''"Datele sunt introduse corect."''', apoi pe un rând nou '''a afișa pe ecran numerele i j, i < j reprezentând numerele de ordine a două secvențe identice, dacă există două astfel de secvențe, sau mesajul NU, dacă nu există două astfel de secvențe, dacă există mai multe perechi de secvențe identice se vor considera cele cu numerele de ordine minime.''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.		'''"Datele sunt introduse corect."''', apoi pe un rând nou '''se va afișa pe ecran numerele i j, i < j reprezentând numerele de ordine a două secvențe identice, dacă există două astfel de secvențe, sau mesajul NU, dacă nu există două astfel de secvențe, dacă există mai multe perechi de secvențe identice se vor considera cele cu numerele de ordine minime.''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''

	== Restricţii şi precizări ==		== Restricţii şi precizări ==
	* 1 ≤ k < n ≤ 1000, k este divizor al lui n		* 1 ≤ k < n ≤ 1000, k este divizor al lui n

Flaviu at 19:55, 14 May 2023

2023-05-14T19:55:04Z

← Older revision		Revision as of 19:55, 14 May 2023
Line 24:		Line 24:
	; Ieșire		; Ieșire
	: Datele nu corespund restricțiilor impuse.		: Datele nu corespund restricțiilor impuse.
	~~: 1 2~~

	== Rezolvare ==		== Rezolvare ==
Line 31:		Line 31:
	# 0521 - kSecventa		# 0521 - kSecventa

	def ~~kSecventa~~(n, k, v):		def validate_input(n, k, arr):
			if k >= n:
			return False
	if n % k != 0:		if n % k != 0:
			return False
			if max(arr) > 1000:
			return False
			return True


			def find_identical_sequences(n, k, arr):
			if not validate_input(n, k, arr):
	print("Datele nu corespund restricțiilor impuse.")		print("Datele nu corespund restricțiilor impuse.")
	return		return

	~~# Impartim lista in k bucati cat mai egale~~		seq_dict = {}
	~~chunk_size = n // k~~		for i in range(n // k):
	~~extra = n % k~~		seq = tuple(arr[i * k: (i + 1) * k])
	~~chunks = []~~		if seq in seq_dict:
	~~start~~ = 0		print(seq_dict[seq], i + 1)
	for i in range(k):		return
	~~end~~ = ~~start~~ + ~~chunk_size~~		else:
	if ~~extra > 0~~:		seq_dict[seq] = i + 1
	~~end~~ += 1
	~~extra -= 1~~
	~~chunks.append(v~~[~~start:end~~])
	~~start~~ = ~~end~~

	~~# Verificam daca exista doua secvente identice~~		print("NU")
	~~for i in range(k):~~
	~~for j in range(i+1, k):~~
	~~if chunks[i] == chunks[j]:~~
	print("~~Datele sunt introduse corect.~~")
	~~print(i+1, j+1)~~
	~~return~~

	~~print("Datele sunt introduse corect.")~~
	~~print("NU")~~

	if __name__ == "__main__":		if __name__ == "__main__":
	n, k = map(int, input().split())		n, k = map(int, input().split())
	v = list(map(int, input().split()))		arr = list(map(int, input().split()))

	~~kSecventa~~(n, k, v)		if validate_input(n, k, arr):
			print("Datele sunt introduse corect.")
			find_identical_sequences(n, k, arr)
			else:
			print("Datele nu corespund restricțiilor impuse.")


	</syntaxhighlight>		</syntaxhighlight>
	== Explicatie Rezolvare ==		== Explicatie Rezolvare ==
	Funcția ~~kSecventa(n, k, v)~~ primește ~~ca argumente lungimea vectorului n, numărul~~ de secvențe ~~k și~~ vectorul v.		Funcția validate_input primește valorile citite de la tastatură și verifică dacă îndeplinesc restricțiile impuse de problemă.
	~~Inițializăm variabila secv_len cu lungimea secvențelor, adică~~ n // k.		Funcția check_sequences primește valorile validate și verifică existența a două secvențe identice în vectorul dat.
	~~Folosim două bucle for pentru a itera prin toate perechile de secvențe și verificăm~~ dacă ~~ele sunt identice, comparând subșirurile corespunzătoare din vectorul v~~.		Se parcurg secvențele de lungime n/k din vector, verificându-se dacă au mai fost întâlnite.
	Dacă ~~găsim două secvențe identice~~, ~~afișăm~~ numerele ~~lor~~ de ordine și ~~opri căutarea cu return~~.		Dacă se găsește o secvență identică, se afișează numerele de ordine ale celor două secvențe și se returnează din funcție.
	Dacă nu ~~găsim~~ nicio ~~pereche de secvențe identice~~, ~~afișăm~~ "NU".		Dacă nu se găsește nicio secvență identică, se afișează mesajul "NU".
	~~În funcția main~~, ~~citim n~~ și ~~k de la tastatură și verificăm dacă datele introduse corespund restricțiilor impuse~~.		Dacă datele nu respectă restricțiile, se afișează mesajul corespunzător și se returnează din funcție.
	~~Dacă~~ datele ~~sunt introduse corect~~, ~~citim vectorul v și apelăm funcția kSecventa(n, k, v) pentru a rezolva problema~~.		Funcția check_sequences este apelată în cadrul blocului if __name__ == "__main__", unde se citesc datele de intrare."__main__", unde se citesc datele de intrare.

Flaviu at 21:15, 13 May 2023

2023-05-13T21:15:22Z

← Older revision		Revision as of 21:15, 13 May 2023
Line 31:		Line 31:
	# 0521 - kSecventa		# 0521 - kSecventa

	def ~~citire_date~~():		def kSecventa(n, k, v):
	n, k = ~~map(int, input().split())~~		if n % k != 0:
	~~x = list(map~~(~~int, input()~~.~~split())~~)		print("Datele nu corespund restricțiilor impuse.")
	return ~~n, k, x~~		return

	~~def numar_secvente(~~n, k~~, x, t):~~		# Impartim lista in k bucati cat mai egale
	~~counter~~ = 0		chunk_size = n // k
	for i in range(n-k+1):		extra = n % k
	~~secventa~~ = ~~x[i:i~~+k]		chunks = []
	if ~~all(e <= t for e in secventa)~~:		start = 0
	~~counter~~ += 1		for i in range(k):
	~~return counter~~		end = start + chunk_size
			if extra > 0:
			end += 1
			extra -= 1
			chunks.append(v[start:end])
			start = end

	~~def valideaza_datele_de_intrare~~(n, k~~, x~~):		# Verificam daca exista doua secvente identice
	~~if not~~ (1 <= k <= ~~n <~~= ~~100000 and all(0 < i < 1000000000 for i in x))~~:		for i in range(k):
	print("Datele ~~nu corespund restricțiilor impuse~~.")		for j in range(i+1, k):
	~~exit~~()		if chunks[i] == chunks[j]:
			print("Datele sunt introduse corect.")
			print(i+1, j+1)
			return

	~~if __name__ == '__main__':~~
	~~n, k, x = citire_date()~~
	~~t = int(input())~~
	~~valideaza_datele_de_intrare(n, k, x)~~
	~~rezultat = numar_secvente(n, k, x, t)~~
	print("Datele sunt introduse corect.")		print("Datele sunt introduse corect.")
	print(~~rezultat~~)		print("NU")

			if __name__ == "__main__":
			n, k = map(int, input().split())
			v = list(map(int, input().split()))

			kSecventa(n, k, v)


	</syntaxhighlight>		</syntaxhighlight>
	== Explicatie Rezolvare ==		== Explicatie Rezolvare ==
	~~Citim datele de intrare~~ (n, k și vectorul x).		Funcția kSecventa(n, k, v) primește ca argumente lungimea vectorului n, numărul de secvențe k și vectorul v.
	~~Calculăm~~ lungimea ~~fiecărei secvențe (l)~~, ~~care este egală cu~~ n/k.		Inițializăm variabila secv_len cu lungimea secvențelor, adică n // k.
	~~Inițializăm un dicționar (seq_dict) în care vom stoca fiecare secvență și numărul de apariții~~ a ~~acesteia.~~		Folosim două bucle for pentru a itera prin toate perechile de secvențe și verificăm dacă ele sunt identice, comparând subșirurile corespunzătoare din vectorul v.
	~~Iterăm~~ prin ~~fiecare secvență (~~de ~~la 1 la k)~~ și:		Dacă găsim două secvențe identice, afișăm numerele lor de ordine și opri căutarea cu return.
	~~a. Extragem secvența~~ corespunzătoare.		Dacă nu găsim nicio pereche de secvențe identice, afișăm "NU".
	b. Dacă ~~secvența nu există deja în dicționar~~, ~~o adăugăm~~ cu ~~valoarea 1~~.		În funcția main, citim n și k de la tastatură și verificăm dacă datele introduse corespund restricțiilor impuse.
	c. Dacă ~~secvența există deja în dicționar~~, ~~o incrementăm cu 1~~.		Dacă datele sunt introduse corect, citim vectorul v și apelăm funcția kSecventa(n, k, v) pentru a rezolva problema.
	~~d. Verificăm dacă secvența a fost întâlnită~~ de ~~două ori~~ și, dacă ~~da, afișăm index-urile secvențelor identice și ieșim din program~~.
	Dacă ~~nu am găsit două secvențe identice~~, ~~afișăm "NU"~~.

Flaviu at 07:21, 3 May 2023

2023-05-03T07:21:49Z

← Older revision		Revision as of 07:21, 3 May 2023
Line 7:		Line 7:
	== Date de ieșire ==		== Date de ieșire ==
	Dacă datele sunt introduse corect, pe ecran se va afișa:		Dacă datele sunt introduse corect, pe ecran se va afișa:
	'''"Datele sunt introduse corect."''', apoi pe un rând nou '''~~numărul c~~''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.== Restricţii şi precizări ==		'''"Datele sunt introduse corect."''', apoi pe un rând nou '''a afișa pe ecran numerele i j, i < j reprezentând numerele de ordine a două secvențe identice, dacă există două astfel de secvențe, sau mesajul NU, dacă nu există două astfel de secvențe, dacă există mai multe perechi de secvențe identice se vor considera cele cu numerele de ordine minime.''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.
			== Restricţii şi precizări ==
	* 1 ≤ k < n ≤ 1000, k este divizor al lui n		* 1 ≤ k < n ≤ 1000, k este divizor al lui n
	* cele n numere citite vor fi mai mici decât 1000		* cele n numere citite vor fi mai mici decât 1000
	== Exemplu ==		== Exemplu 1 ==
	; Intrare		; Intrare
	: 15 5		: 15 5
	: 3 6 4 7 6 6 6 4 6 7 6 6 4 4 5		: 3 6 4 7 6 6 6 4 6 7 6 6 4 4 5
			; Ieșire
			: Datele sunt introduse corect.
			: 2 4
			== Exemplu 2 ==
			; Intrare
			: 3 2
			: 1 1 2 3 2 6 7 8 2 4 1 1 2 3
	; Ieșire		; Ieșire
	: Datele nu corespund restricțiilor impuse.		: Datele nu corespund restricțiilor impuse.
	: 2 4		: 1 2

	== Rezolvare ==		== Rezolvare ==

Flaviu at 18:04, 27 April 2023

2023-04-27T18:04:00Z

← Older revision		Revision as of 18:04, 27 April 2023
Line 6:		Line 6:
	Programul citește de la tastatură numerele n și k, iar apoi n numere naturale, reprezentând elementele vectorului.		Programul citește de la tastatură numerele n și k, iar apoi n numere naturale, reprezentând elementele vectorului.
	== Date de ieșire ==		== Date de ieșire ==
	~~Programul~~ va afișa pe ~~ecran numerele i j~~, ~~i < j~~ reprezentând ~~numerele de ordine a două secvențe identice~~, ~~dacă există două astfel de secvențe, sau mesajul NU, dacă~~ nu ~~există două astfel de secvențe~~.		Dacă datele sunt introduse corect, pe ecran se va afișa:
	~~Dacă există mai multe perechi de secvențe identice se vor considera cele cu numerele de ordine minime~~.		'''"Datele sunt introduse corect."''', apoi pe un rând nou '''numărul c''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.== Restricţii şi precizări ==
	== Restricţii şi precizări ==
	* 1 ≤ k < n ≤ 1000, k este divizor al lui n		* 1 ≤ k < n ≤ 1000, k este divizor al lui n
	* cele n numere citite vor fi mai mici decât 1000		* cele n numere citite vor fi mai mici decât 1000
Line 16:		Line 15:
	: 3 6 4 7 6 6 6 4 6 7 6 6 4 4 5		: 3 6 4 7 6 6 6 4 6 7 6 6 4 4 5
	; Ieșire		; Ieșire
			: Datele nu corespund restricțiilor impuse.
	: 2 4		: 2 4

Line 23:		Line 23:
	# 0521 - kSecventa		# 0521 - kSecventa

	def ~~citeste_date_intrare~~():		def citire_date():
	n, k = map(int, input().split())		n, k = map(int, input().split())
	x = list(map(int, input().split()))		x = list(map(int, input().split()))
	return n, k, x		return n, k, x

	def ~~gaseste_secvente_identice~~(n, k, x):		def numar_secvente(n, k, x, t):
	l = ~~n // k~~		counter = 0
	~~seq_dict = {}~~		for i in range(n-k+1):
	for i in range(1, k+1):		secventa = x[i:i+k]
	~~seq~~ = ~~tuple(~~x[(i~~-1)l~~:il])		if all(e <= t for e in secventa):
	if ~~seq not in seq_dict:~~		counter += 1
	~~seq_dict[seq]~~ = 1		return counter
	~~else:~~
	~~seq_dict[seq] += 1~~
	~~if seq_dict[seq] == 2:~~
	for j in ~~range(1, i~~):
	~~if seq~~ =~~= tuple(x[(j-~~1~~)l:jl]):~~
	~~return j, i~~
	return ~~"NU"~~

	def valideaza_datele_de_intrare(n, k, x):		def valideaza_datele_de_intrare(n, k, x):
	~~assert~~ 1 <= k < n <= ~~1000~~ and ~~n % k ==~~ 0, "Datele ~~de intrare sunt incorecte!~~"		if not (1 <= k <= n <= 100000 and all(0 < i < 1000000000 for i in x)):
	~~assert max~~(x) ~~< 1000, "Datele de intrare sunt incorecte!"~~		print("Datele nu corespund restricțiilor impuse.")
			exit()

	if __name__ == '__main__':		if __name__ == '__main__':
	n, k, x = ~~citeste_date_intrare~~()		n, k, x = citire_date()
			t = int(input())
	valideaza_datele_de_intrare(n, k, x)		valideaza_datele_de_intrare(n, k, x)
	rezultat = ~~gaseste_secvente_identice~~(n, k, x)		rezultat = numar_secvente(n, k, x, t)
			print("Datele sunt introduse corect.")
	print(rezultat)		print(rezultat)


	</syntaxhighlight>		</syntaxhighlight>

Flaviu at 19:52, 17 April 2023

2023-04-17T19:52:39Z

← Older revision		Revision as of 19:52, 17 April 2023
Line 23:		Line 23:
	# 0521 - kSecventa		# 0521 - kSecventa

	n, k = map(int, input().split())		def citeste_date_intrare():
	v = list(map(int, input().split()))		n, k = map(int, input().split())
			x = list(map(int, input().split()))
			return n, k, x

	~~size~~ = n // k		def gaseste_secvente_identice(n, k, x):
	d = {}		l = n // k
			seq_dict = {}
			for i in range(1, k+1):
			seq = tuple(x[(i-1)l:il])
			if seq not in seq_dict:
			seq_dict[seq] = 1
			else:
			seq_dict[seq] += 1
			if seq_dict[seq] == 2:
			for j in range(1, i):
			if seq == tuple(x[(j-1)l:jl]):
			return j, i
			return "NU"

	~~for i in range~~(k):		def valideaza_datele_de_intrare(n, k, x):
	~~start~~ = ~~i * size~~		assert 1 <= k < n <= 1000 and n % k == 0, "Datele de intrare sunt incorecte!"
	~~end~~ = ~~start + size~~		assert max(x) < 1000, "Datele de intrare sunt incorecte!"
	~~seq~~ = ~~tuple~~(~~v[start:end]) # convertim secventa la un obiect imutabil (tuplu~~)
	~~if seq in d:~~		if __name__ == '__main__':
	~~print~~(~~d[seq]~~, ~~i+1~~)		n, k, x = citeste_date_intrare()
	~~break~~		valideaza_datele_de_intrare(n, k, x)
	~~else:~~		rezultat = gaseste_secvente_identice(n, k, x)
	~~d[seq]~~ = ~~i+1~~		print(rezultat)
	~~else:~~
	print(~~"NU"~~)


	</syntaxhighlight>		</syntaxhighlight>
			== Explicatie Rezolvare ==
			Citim datele de intrare (n, k și vectorul x).
			Calculăm lungimea fiecărei secvențe (l), care este egală cu n/k.
			Inițializăm un dicționar (seq_dict) în care vom stoca fiecare secvență și numărul de apariții a acesteia.
			Iterăm prin fiecare secvență (de la 1 la k) și:
			a. Extragem secvența corespunzătoare.
			b. Dacă secvența nu există deja în dicționar, o adăugăm cu valoarea 1.
			c. Dacă secvența există deja în dicționar, o incrementăm cu 1.
			d. Verificăm dacă secvența a fost întâlnită de două ori și, dacă da, afișăm index-urile secvențelor identice și ieșim din program.
			Dacă nu am găsit două secvențe identice, afișăm "NU".

Flaviu: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/521/ksecventa 0521 - kSecventa] ---- == Cerinţa == Se dă un vector cu n elemente, numere naturale, și un număr k, divizor al lui n. Se împarte vectorul în k secvențe disjuncte, numerotate de la 1 la k. Să se stabilească dacă există două secvențe identice. == Date de intrare == Programul citește de la tastatură numerele n și k, iar apoi n numere naturale, reprezentând elementele vectorului. == Date de ieșire == Programu...

2023-03-21T21:20:19Z

Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/521/ksecventa 0521 - kSecventa] ---- == Cerinţa == Se dă un vector cu n elemente, numere naturale, și un număr k, divizor al lui n. Se împarte vectorul în k secvențe disjuncte, numerotate de la 1 la k. Să se stabilească dacă există două secvențe identice. == Date de intrare == Programul citește de la tastatură numerele n și k, iar apoi n numere naturale, reprezentând elementele vectorului. == Date de ieșire == Programu...

New page

Sursa: [https://www.pbinfo.ro/probleme/521/ksecventa 0521 - kSecventa]
----
== Cerinţa ==
Se dă un vector cu n elemente, numere naturale, și un număr k, divizor al lui n. Se împarte vectorul în k secvențe disjuncte, numerotate de la 1 la k. Să se stabilească dacă există două secvențe identice.
== Date de intrare ==
Programul citește de la tastatură numerele n și k, iar apoi n numere naturale, reprezentând elementele vectorului.
== Date de ieșire ==
Programul va afișa pe ecran numerele i j, i < j reprezentând numerele de ordine a două secvențe identice, dacă există două astfel de secvențe, sau mesajul NU, dacă nu există două astfel de secvențe.
Dacă există mai multe perechi de secvențe identice se vor considera cele cu numerele de ordine minime.
== Restricţii şi precizări ==
* 1 ≤ k < n ≤ 1000, k este divizor al lui n
* cele n numere citite vor fi mai mici decât 1000
== Exemplu ==
; Intrare
: 15 5
: 3 6 4 7 6 6 6 4 6 7 6 6 4 4 5
; Ieșire
: 2 4

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0521 - kSecventa

n, k = map(int, input().split())
v = list(map(int, input().split()))

size = n // k
d = {}

for i in range(k):
start = i * size
end = start + size
seq = tuple(v[start:end]) # convertim secventa la un obiect imutabil (tuplu)
if seq in d:
print(d[seq], i+1)
break
else:
d[seq] = i+1
else:
print("NU")

</syntaxhighlight>