MainActivity
import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
class MainActivity : AppCompatActivity() {
val lostArray = arrayOf(10000, 2300, 45000, 65000, 6500, 400)
val earnArray = arrayOf(15000, 300, 345000, 5000, 16500, 3400)
val resultArray = ArrayList<String>()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val names = resources.getStringArray(R.array.names)
for((index, name) in names.withIndex()){
resultArray.add("Имя: $name - прибыль = ${earnArray[index] - lostArray[index]}")
Log.d("MyLog", "Статистика -/- ${resultArray[index]}")
}
}
}
arrays.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string-array name="names">
<item>Егор</item>
<item>Андрей</item>
<item>Маша</item>
<item>Света</item>
<item>Максим</item>
<item>Петр</item>
</string-array>
</resources>
Домашнее задание:
Скопируйте класс MainActivity который найдете ниже и допишите код для того чтобы получить в панеле LogCat результат который указан ниже. У нас есть интервалы которые обозначают качество оценки: bad, normal, nice, excellent. еще у нас есть массив с оценками gradeArray и массив с учениками nameArray. Ваша задача используя цикл отсортировать учеников с оценками по группам, в результате выход в панели LogCat должен получится такой:
Плохие оценки: Ученик: Маша – 3
Плохие оценки: Ученик: Семен – 2
Нормальные оценки: Ученик: Антон – 4
Нормальные оценки: Ученик: Светлана – 6
Хорошие оценки: Ученик: Егор – 7
Отличные оценки: Ученик: Юля – 10
MainActivity (ДЗ)
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
class MainActivity : AppCompatActivity() {
val bad = 0..3
val normal = 4..6
val nice = 7..9
val excellent = 10
val gradeArray = arrayOf(4, 7, 3, 6, 10, 2)
val nameArray = arrayOf("Антон", "Егор", "Маша", "Светлана", "Юля", "Семен")
val badArray = ArrayList<String>()
val normalArray = ArrayList<String>()
val niceArray = ArrayList<String>()
val excellentArray = ArrayList<String>()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
}
}
badArray.forEach {Log.d(“MyLog”, it)}
normalArray.forEach {Log.d(“MyLog”, it)}
normalArray.forEach {Log.d(“MyLog”, it)}
excellentArray.forEach {Log.d(“MyLog”, it)}
Отлично! Но не вижу заполнения списков)
for ((index, grade) in gradeArray.withIndex()) {
if (grade in bad) badArray.add(“Ученик: ${nameArray[index]} – $grade”)
if (grade in normal) normalArray.add(“Ученик: ${nameArray[index]} – $grade”)
if (grade in nice) niceArray.add(“Ученик: ${nameArray[index]} – $grade”)
if (grade == excellent) excellentArray.add(“Ученик: ${nameArray[index]} – $grade”)
}
badArray.forEach {Log.d(“MyLog”, “Плохие оценки: $it”)}
normalArray.forEach {Log.d(“MyLog”, “Нормальные оценки: $it”)}
niceArray.forEach {Log.d(“MyLog”, “Хорошие оценки: $it”)}
excellentArray.forEach {Log.d(“MyLog”, “Отличные оценки: $it”)}
Отлично, но лучше в таком случае использовать when а не if
І тепер кожен спише д/з
for ((index, grade) in gradeArray.withIndex()) {
when(grade){
in bad -> {badArray.add(“Ученик: ${nameArray[index]} – $grade”)}
in normal -> {normalArray.add(“Ученик: ${nameArray[index]} – $grade”)}
in nice -> { niceArray.add(“Ученик: ${nameArray[index]} – $grade”)}
excellent -> { excellentArray.add(“Ученик: ${nameArray[index]} – $grade”)}
}
}
badArray.forEach {println( “Плохие оценки: $it”)}
normalArray.forEach {println( “Нормальные оценки: $it”)}
niceArray.forEach {println( “Хорошие оценки: $it”)}
excellentArray.forEach {println( “Отличные оценки: $it”)}
for (i in gradeArray.indices){
when(gradeArray[i]) {
in bad -> badArray.add(“Плохие оценки: Ученик: ${nameArray[i]} – ${gradeArray[i]}”)
in normal -> normalArray.add(“Нормальные оценки: Ученик: ${nameArray[i]} – ${gradeArray[i]}”)
in nice -> niceArray.add(“Хорошие оценки: Ученик: ${nameArray[i]} – ${gradeArray[i]}”)
else -> excellentArray.add(“Отличные оценки: Ученик: ${nameArray[i]} – ${gradeArray[i]}”)
}
}
badArray.forEach{Log.d(“MyLog”, it)}
normalArray.forEach{Log.d(“MyLog”, it)}
niceArray.forEach{Log.d(“MyLog”, it)}
excellentArray.forEach{Log.d(“MyLog”, it)}
for ((index, name) in nameArray.withIndex()) {
when (gradeArray[index]) {
in bad -> {
badArray.add(“Плохие оценки : Ученик : $name – ${gradeArray[index]}”)
}
in normal -> {
normalArray.add(“Нормальные оценки : Ученик : $name – ${gradeArray[index]}”)
}
in nice -> {
niceArray.add(“Хорошие оценки : Ученик : $name – ${gradeArray[index]}”)
}
else -> {
excellentArray.add(“Отличные оценки : Ученик : $name – ${gradeArray[index]}”)
}
}
}
badArray.forEach {
Log.d(“WATCH”, “$it”)
}
normalArray.forEach {
Log.d(“WATCH”, “$it”)
}
niceArray.forEach {
Log.d(“WATCH”, “$it”)
}
excellentArray.forEach {
Log.d(“WATCH”, “$it”)
}
for ((index, value) in gradeArray.withIndex()) {
when (value) {
in bad -> badArray.add(“Плохие оценки: Ученик: ${nameArray[index]} – $value”)
in normal -> normalArray.add(“Нормальные оценки: Ученик: ${nameArray[index]} – $value”)
in nice -> niceArray.add(“Хорошие оценки: Ученик: ${nameArray[index]} – $value”)
excellent -> excellentArray.add(“Отличные оценки: Ученик: ${nameArray[index]} – $value”)
}
}
Log.d(
“MyLog”, “${badArray.joinToString(separator = “\n”)}\n” +
“${normalArray.joinToString(separator = “\n”)}\n” +
“${niceArray.joinToString(separator = “\n”)}\n” +
excellentArray.joinToString(separator = “\n”)
)
for (i in nameArray.indices) {
when (gradeArray[i]) {
in bad -> badArray.add(“${nameArray[i]} – ${gradeArray[i]}”)
in normal -> normalArray.add(“${nameArray[i]} – ${gradeArray[i]}”)
in nice -> niceArray.add(“${nameArray[i]} – ${gradeArray[i]}”)
excellent -> excellentArray.add(“${nameArray[i]} – ${gradeArray[i]}”)
}
}
badArray.forEach() {
Log.d(“MyLog”, “Плохие оценки: Ученик: $it”)
}
normalArray.forEach() {
Log.d(“MyLog”, “Нормальные оценки: Ученик: $it”)
}
niceArray.forEach() {
Log.d(“MyLog”, “Хорошие оценки: Ученик: $it”)
}
excellentArray.forEach() {
Log.d(“MyLog”, “Отличные оценки: Ученик: $it”)
}
У меня что самый гигантский код получился?
for((index, name) in nameArray.withIndex()){
for(i in bad){
if(gradeArray[index] == i){ badArray.add(“Плохие оценки: Ученик: $name – ${gradeArray[index]}”)}
}
}
for((index, name) in nameArray.withIndex()){
for(i in normal){
if(gradeArray[index] == i){ normalArray.add(“Нормальные оценки: Ученик: $name – ${gradeArray[index]}”)}
}
}
for((index, name) in nameArray.withIndex()){
for(i in nice){
if(gradeArray[index] == i){ niceArray.add(“Хорошие оценки: Ученик: $name – ${gradeArray[index]}”)}
}
}
for((index, name) in nameArray.withIndex()){
if(gradeArray[index] == excellent){ excellentArray.add(“Отличные оценки: Ученик: $name – ${gradeArray[index]}”)}
}
for(index in badArray.indices){Log.d(“MyLog”, “${badArray[index]}”)}
for(index in normalArray.indices){Log.d(“MyLog”, “${normalArray[index]}”)}
for(index in niceArray.indices){Log.d(“MyLog”, “${niceArray[index]}”)}
for(index in excellentArray.indices){Log.d(“MyLog”, “${excellentArray[index]}”)}
//формируем массивы
for((index, name) in nameArray.withIndex()){
if(gradeArray[index] in bad) badArray.add(
“$name – ${gradeArray[index]}”)
else if(gradeArray[index] in normal) normalArray.add(
“$name – ${gradeArray[index]}”)
else if(gradeArray[index] in nice) niceArray.add(
“$name – ${gradeArray[index]}”)
else if(gradeArray[index] == excellent) excellentArray.add(
“$name – ${gradeArray[index]}”)
}
//печать
for (i in 0 .. (badArray.size – 1))
Log.d(“MyLog”,”Плохие оценки: ${badArray[i]}”)
for (i in 0 .. (normalArray.size – 1))
Log.d(“MyLog”,”Нормальные оценки: ${normalArray[i]}”)
for (i in 0 .. (niceArray.size – 1))
Log.d(“MyLog”,”Хорошие оценки: ${niceArray[i]}”)
for (i in 0 .. (excellentArray.size – 1))
Log.d(“MyLog”,”Отличные оценки: ${excellentArray[i]}”)
for((i, name) in nameArray.withIndex()) {
when (gradeArray[i]) {
in bad -> badArray.add(“Плохие оценки: Ученик: $name – ${gradeArray[i]}”)
in normal -> normalArray.add(“Нормальные оценки: Ученик: $name – ${gradeArray[i]}”)
in nice -> niceArray.add(“Хорошие оценки: Ученик: $name – ${gradeArray[i]}”)
excellent -> excellentArray.add(“Отличные оценки: Ученик: $name – ${gradeArray[i]}”)
}
}
badArray.forEach{Log.d(“MyLog”,”$it”)}
normalArray.forEach{Log.d(“MyLog”,”$it”)}
niceArray.forEach{Log.d(“MyLog”,”$it”)}
excellentArray.forEach{Log.d(“MyLog”,”$it”)}
for ((i, name) in nameArray.withIndex()) {
when (gradeArray[i]) {
in bad -> badArray.add(“Плохие оценки: Ученик: $name – ${gradeArray[i]}”)
in normal -> normalArray.add(“Нормальные оценки: Ученик: $name – ${gradeArray[i]}”)
in nice -> niceArray.add(“Хорошие оценки: Ученик: $name – ${gradeArray[i]}”)
10 -> excellentArray.add(“Отличные оценки: Ученик: $name – ${gradeArray[i]}”)
}
}
arrayOf(badArray, normalArray, niceArray, excellentArray)
.forEach {
it.forEach{
Log.d(“MyLog”, it)
}
}
for((a, b) in gradeArray.withIndex()) {
when (b) {
in bad -> {
badArray.add(“${nameArray[a]} – ${gradeArray[a]}”)
}
in normal -> {
normalArray.add(“${nameArray[a]} – ${gradeArray[a]}”)
}
in nice -> {
niceArray.add(“${nameArray[a]} – ${gradeArray[a]}”)
}
excellent -> {
excellentArray.add(“${nameArray[a]} – ${gradeArray[a]}”)
}
}
}
badArray.forEach { Log.d(“MyLog”, “Плохие оценки: Ученик: $it”) }
normalArray.forEach { Log.d(“MyLog”, “Нормальные оценки: Ученик: $it”) }
niceArray.forEach { Log.d(“MyLog”, “Хорошие оценки: Ученик: $it”) }
excellentArray.forEach { Log.d(“MyLog”, “Отличные оценки: Ученик: $it”) }
for ((index, score) in gradeArray.withIndex()){
when(score){
in bad -> badArray.add(“Плохие оценки: Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
in normal -> normalArray.add(“Нормальные оценки: Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
in nice -> niceArray.add(“Хорошие оценки: Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
excellent -> excellentArray.add(“Отличные оценки: Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
}
}
badArray.forEach {Log.d(“MyLog”, it)}
normalArray.forEach {Log.d(“MyLog”, it)}
niceArray.forEach {Log.d(“MyLog”, it)}
excellentArray.forEach {Log.d(“MyLog”, it)}
а куда пропал мой коментарий ?
Оставлю свой след в истории!
for((index, name) in nameArray.withIndex()){
when(gradeArray[index]){
in bad -> badArray.add(“Плохие оценки: Ученик – $name – ${gradeArray[index]}”)
in normal -> normalArray.add(“Нормальные оценки: Ученик – $name – ${gradeArray[index]}”)
in nice -> niceArray.add(“Хорошие оценки: Ученик – $name – ${gradeArray[index]}”)
excellent -> excellentArray.add(“Отличные оценки: Ученик – $name – ${gradeArray[index]}”)
}
}
badArray.forEach {
Log.d(“MyTag”, it)
}
normalArray.forEach {
Log.d(“MyTag”, it)
}
niceArray.forEach {
Log.d(“MyTag”, it)
}
excellentArray.forEach {
Log.d(“MyTag”, it)
}
for ((index, name) in nameArray.withIndex()) {
when (gradeArray[index]) {
in bad -> badArray.add(“$name – ${gradeArray[index]}”)
in normal -> normalArray.add(“$name – ${gradeArray[index]}”)
in nice -> niceArray.add(“$name – ${gradeArray[index]}”)
excellent -> excellentArray.add(“$name – ${gradeArray[index]}”)
}
}
Log.d(“MyLog”, “Плохо: ${badArray.joinToString(separator = ” / “)}”)
Log.d(“MyLog”, “Нормально: ${normalArray.joinToString(separator = ” / “)}”)
Log.d(“MyLog”, “Хорошо: ${niceArray.joinToString(separator = ” / “)}”)
Log.d(“MyLog”, “Отлично: ${excellentArray.joinToString(separator = ” / “)}”)
for ((index, grade) in gradeArray.withIndex()) {
if (grade in bad) badArray.add(“Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
if (grade in normal) normalArray.add(“Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
if (grade in nice) niceArray.add(“Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
if (grade == excellent) excellentArray.add(“Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
}
result.addAll(badArray)
result.addAll(normalArray)
result.addAll(niceArray)
result.addAll(excellentArray)
result.forEach{
Log.d(“MyLog”, “Statistic: -/- $it”)
}
}
Что то я немного намудрил… но тоже работает
gradeArray.forEach {
if (it in bad){
for ((index, number) in gradeArray.withIndex()){
if (number == it) {
badArray.add(“Плохие оценки у ученика: ${nameArray[index]}, оценка: ${it.toString()}”)
Log.d(“MyLog”, “${badArray[badArray.size-1]}”)
}
}
}
}
gradeArray.forEach {
if (it in normal){
for ((index, number) in gradeArray.withIndex()){
if (number == it) {
normalArray.add(“Нормальные оценки у ученика: ${nameArray[index]}, оценка: ${it.toString()}”)
Log.d(“MyLog”, “${normalArray[normalArray.size-1]}”)
}
}
}
}
gradeArray.forEach {
if (it in nice){
for ((index, number) in gradeArray.withIndex()){
if (number == it) {
niceArray.add(“Отличные оценки у ученика: ${nameArray[index]}, оценка: ${it.toString()}”)
Log.d(“MyLog”, “${niceArray[niceArray.size-1]}”)
}
}
}
}
gradeArray.forEach {
if (it == excellent){
for ((index, number) in gradeArray.withIndex()){
if (number == it) {
excellentArray.add(“Нормальные оценки у ученика: ${nameArray[index]}, оценка: ${it.toString()}”)
Log.d(“MyLog”, “${excellentArray[excellentArray.size-1]}”)
}
}
}
}
Я не совсем понял зачем мы их по массивам раскидываем, если вывести можно просто сравнить и сразу вывести.
val bad = 0..3
val normal = 4..6
val nice = 7..9
val excellent = 10
val gradeArray = arrayOf(4, 7, 3, 6, 10, 2)
val badArray = ArrayList()
val normalArray = ArrayList()
val niceArray = ArrayList()
val excellentArray = ArrayList()
var status = “”
val nameArray = arrayOf(“Антон”, “Егор”, “Маша”, “Светлана”, “Юля”, “Семен”)
for ((index,value) in gradeArray.withIndex()){
if(gradeArray[index] in bad){
badArray.add(nameArray[index])
status=”Плохие оценки:”
}else if(gradeArray[index] in normal){
normalArray.add(nameArray[index])
status=”Нормальные оценки:”
}else if (gradeArray[index] in nice){
niceArray.add(nameArray[index])
status=”Хорошие оценки:”
}else if (gradeArray[index] == excellent){
excellentArray.add(nameArray[index])
status=”Отличные оценки:”
}
Log.d(“MyTest”,”$status ${nameArray[index]}-${gradeArray[index]}”)
}
для дальнейшего использования например, цель то не вывести а распределить и вывести
Моё примитивнейшее решение, в стиле индуса, наверное. Пришлось наваять переменных, ибо без них крашилось. Но зато без всяких незнакомых на данном этапе конструкций, как у комментаторов выше, типа “joinToString(separator = ” / “)”
for ((index, mark) in gradeArray.withIndex()){
when (mark) {
in bad -> {val message = “Ученик: ${nameArray[index]} – $mark”
badArray.add(message)
Log.d(“MyLog”, “Плохие оценки: $message”) }
in normal -> { val message = “Ученик: ${nameArray[index]} – $mark”
normalArray.add(message)
Log.d(“MyLog”, “Нормальные оценки: $message”) }
in nice -> { val message = “Ученик: ${nameArray[index]} – $mark”
niceArray.add(message)
Log.d(“MyLog”, “Хорошие оценки: $message”) }
excellent -> {val message = “Ученик: ${nameArray[index]} – $mark”
excellentArray.add(message)
Log.d(“MyLog”, “Отличные оценки: $message”) }
}
}
Невнимательно прочитал задание и сделал фигню. Вот итоговый код:
for ((index, mark) in gradeArray.withIndex()) {
when (mark) {
in bad -> {
badArray.add(“Ученик: ${nameArray[index]} – $mark”)
}
in normal -> {
normalArray.add(“Ученик: ${nameArray[index]} – $mark”)
}
in nice -> {
niceArray.add(“Ученик: ${nameArray[index]} – $mark”)
}
excellent -> {
excellentArray.add(“Ученик: ${nameArray[index]} – $mark”)
}
}
}
badArray.forEach{Log.d(“MyLog”, “Плохие оценки:$it”)}
normalArray.forEach{Log.d(“MyLog”, “Нормальные оценки:$it”)}
niceArray.forEach{Log.d(“MyLog”, “Хорошие оценки:$it”)}
excellentArray.forEach{Log.d(“MyLog”, “Отличные оценки:$it”)}
}
class MainActivity : AppCompatActivity() {
lateinit var bindingClass : ActivityMainBinding
val estimArray = arrayOf(3, 2, 4 , 6, 7, 10)
val resulArray = ArrayList()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
bindingClass = ActivityMainBinding.inflate(layoutInflater)
setContentView(bindingClass.root)
val names = resources.getStringArray(R.array.names)
for((index, name) in names.withIndex()){
val estim = evaluationQality(estimArray[index])
resulArray.add(“$estim Ученик: $name – ${estimArray[index]}”)
}
resulArray.forEach{el -> Log.d(“MyLog”, “$el”)}
}
fun evaluationQality(items: Int): String{
var result = “empty”
if(items in 0..3) result = “Плохие оценки:”
else if(items in 4..6) result = “Нормальные оценки:”
else if(items in 7..8) result = “Хорошие оценки:”
else if(items in 9..10) result = “Отличные оценки:”
else result = “”
return result
}
}
совсем забыл про forEach и в итоге написал дико костыльный но хотябы рабочий вывод
for (index in 0 until gradeArray.size){
if (index < badArray.size)
Log.d("MyLog", "Плохая оценка ${badArray[index]}")
else if (index < normalArray.size + badArray.size)
Log.d("MyLog", "Норм оценка ${normalArray[index – badArray.size]}")
else if (index < niceArray.size + normalArray.size + badArray.size)
Log.d("MyLog", "Хорошая оценка ${niceArray[index – normalArray.size – badArray.size]}")
else if (index < excellentArray.size + niceArray.size + normalArray.size + badArray.size)
Log.d("MyLog", "Отличная оценка ${excellentArray[index – niceArray.size – normalArray.size – badArray.size]}")
}
for((index, name) in nameArray.withIndex()){
when(gradeArray[index]) {
in bad -> badArray.add( “Плохие оценки: ученик $name – ${gradeArray [index]}” )
in normal -> normalArray.add( “Нормальные оценки : ученик $name – ${gradeArray[index]}”)
in nice -> niceArray.add (“Хорошие оценки : ученик $name – ${gradeArray[index]} “)
excellent -> excellentArray.add( “Отличные: ученик $name – ${gradeArray[index]}”)
badArray.forEach {Log.d(“MyLog”, ” $it”)}
normalArray.forEach {Log.d(“MyLog”, ” $it”)}
niceArray.forEach {Log.d(“MyLog”, ” $it”)}
excellentArray.forEach{Log.d(“MyLog”, ” $it”)}
При вводе слова exellent его подсвечивает красным и пишет “Unresolved reference: exellent”. Как исправить ошибку?
может вы перед ним используете in, нужно просто ==
в слове exellent пропущена “c”
for ((index, grade) in gradeArray.withIndex()) {
if (grade in bad) {
badArray.add(“Bad grades: Student:${nameArray[index]} – ${gradeArray[index]}”)
}
else if (grade in normal) {
normalArray.add(“Normal grades: Student:${nameArray[index]} – ${gradeArray[index]}”)
}
else if (grade in nice) {
niceArray.add(“Nice grades: Student:${nameArray[index]} – ${gradeArray[index]}”)
}
else if (grade == excellent) {
excellentArray.add(“Excellent grades: Student:${nameArray[index]} – ${gradeArray[index]}”)
}
for ((i, name) in nameArray.withIndex()) {
when (gradeArray[i]) {
in bad -> badArray.add(“Плохие оценки: Ученик: $name – ${gradeArray[i]}”)
in normal -> normalArray.add(“Нормальные оценки: Ученик: $name – ${gradeArray[i]}”)
in nice -> niceArray.add(“Хорошие оценки: Ученик: $name – ${gradeArray[i]}”)
excellent -> excellentArray.add(“Отличные оценки: Ученик: $name – ${gradeArray[i]}”)
}
}
val resultArray = ArrayList(badArray)
resultArray.addAll(normalArray)
resultArray.addAll(niceArray)
resultArray.addAll(excellentArray)
resultArray.forEach { Log.d(“MyLog”, it) }
for ((index, grade) in gradeArray.withIndex()) {
when (grade) {
in bad -> {
badArray.add(“Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
}
in normal -> {
normalArray.add(“Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
}
in nice -> {
niceArray.add(“Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
}
excellent -> {
excellentArray.add(“Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
}
}
}
badArray.forEach() {Log.d (“rul”, “Плохие оценки: $it”)}
normalArray.forEach() {Log.d (“rul”, “Нормальные оценки: $it”)}
niceArray.forEach() {Log.d (“rul”, “Хорошие оценки: $it”)}
excellentArray.forEach() {Log.d (“rul”, “Отличные оценки: $it”)}
Не могу понять, почему не работает, лог показывает только Антона((
for(index in gradeArray.indices){
if(gradeArray[index] in bad) {
badArray.add(“Плохие оценки: ${nameArray[index]}: – ${gradeArray[index]}”)
Log.d(“MyLog”, badArray[index])
}
if(gradeArray[index] in normal) {
normalArray.add(“Хорошие оценки: ${nameArray[index]}: – ${gradeArray[index]}”)
Log.d(“MyLog”, normalArray[index])
}
if(gradeArray[index] in nice) {
niceArray.add(“Хорошие оценки: ${nameArray[index]}: – ${gradeArray[index]}”)
Log.d(“MyLog”, niceArray[index])
}
if(gradeArray[index] == excellent) {
badArray.add(“Отличные: ${nameArray[index]}: – ${gradeArray[index]}”)
Log.d(“MyLog”, excellentArray[index])
}
}
У меня почему -то вывод в лог задваивается. По два раза одно и то же имя выводит
for (index in gradeArray.indices) {
when (gradeArray[index]) {
in bad ->
badArray.add(“Плохие оценки: Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
in normal ->
normalArray.add(“Нормальные оценки: Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
in nice ->
niceArray.add(“Хорошие оценки: Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
excellent ->
excellentArray.add(“Отличные оценки: Ученик: ${nameArray[index]} – ${gradeArray[index]}”)
}
}
val resultArray = badArray + normalArray + niceArray + excellentArray
resultArray.forEach {
println(it)
}
Вставлю свои 5 копеек, костыльно, но работает
for (index in 0 until gradeArray.size)
{
if (gradeArray[index] in bad)
badArray.add(“${nameArray[index]}, ${gradeArray[index]}”)
if (gradeArray[index] in normal)
normalArray.add(“${nameArray[index]}, ${gradeArray[index]}”)
if (gradeArray[index] in nice)
niceArray.add(“${nameArray[index]}, ${gradeArray[index]}”)
if (gradeArray[index] == excellent)
excellentArray.add(“${nameArray[index]}, ${gradeArray[index]}”)
//Log.d(“MyLog”,”$badArray $normalArray $niceArray $excellentArray”)
}
Log.d(“MyLog”,”плохие баллы – $badArray норм баллы – $normalArray найс болз” +
” $niceArray идеальный болз $excellentArray”)
}
Для тех, кто практику делает в IntelliJ IDEA, а результаты выводит в консольку (я тупил, когда выводил в консоль результирующий список с изменёнными данными, т.к. я впервые работал с forEach):
fun main(args: Array) {
var bad = 0..3
val normal = 4..6
val nice = 7..9
val excellent = 10
var gradeArray = arrayOf(4, 7, 3, 6, 10, 2)
val nameArray = arrayOf(“Антон”, “Егор”, “Маша”, “Светлана”, “Юля”, “Семен”)
val badArray = ArrayList()
val normalArray = ArrayList()
val niceArray = ArrayList()
val excellentArray = ArrayList()
for ((index, name) in nameArray.withIndex()) {
if (gradeArray[index] in bad) {
badArray.add(“Плохие оценки: Ученик: $name – ${gradeArray[index]}”)
}
if (gradeArray[index] in normal) {
normalArray.add(“Нормальные оценки: Ученик: $name – ${gradeArray[index]}”)
}
if (gradeArray[index] in nice) {
niceArray.add(“Хорошие оценки: Ученик: $name – ${gradeArray[index]}”)
}
if (gradeArray[index] == excellent) {
excellentArray.add(“Отличные оценки: Ученик: $name – ${gradeArray[index]}”)
}
}
badArray.forEach {
println(it)
}
normalArray.forEach {
println(it)
}
niceArray.forEach {
println(it)
}
excellentArray.forEach {
println(it)
}
}
Без логов – вывод на println. Оказалось много лишнего:
fun main() {
// val bad = 0..3
// val normal = 4..6
// val nice = 7..9
// val excellent = 10
val gradeArray = arrayOf(4, 7, 3, 6, 10, 2)
val nameArray = arrayOf(“Антон”, “Егор”, “Маша”, “Светлана”, “Юля”, “Семен”)
// val badArray = ArrayList()
// val normalArray = ArrayList()
// val niceArray = ArrayList()
// val excellentArray = ArrayList()
for((index, value) in gradeArray.withIndex()) {
val result = when (value) {
0 -> “bad”
1 -> “bad”
2 -> “bad”
3 -> “bad”
4 -> “normal”
5 -> “normal”
6 -> “normal”
7 -> “nice”
8 -> “nice”
9 -> “nice”
10 -> “excellent”
else -> “error”
}
println(“${nameArray[index]} – $result – ${gradeArray[index]}”)
}
for ((index, grade) in gradeArray.withIndex()){
if(grade in bad){ badArray.add(“Ученик: ${nameArray[index]} : ${gradeArray[index]}”)}
if(grade in normal) normalArray.add(“Ученик: ${nameArray[index]} : ${gradeArray[index]}”)
if(grade in nice) niceArray.add(“Ученик: ${nameArray[index]} : ${gradeArray[index]}”)
if(grade == excellent) excellentArray.add(“Ученик: ${nameArray[index]} : ${gradeArray[index]}”)
}
Log.d(“My log”, “Плохие оценки: $badArray”)
Log.d(“My log”, “Нормальные оценки: $normalArray”)
Log.d(“My log”, “Хорошие оценки: $niceArray”)
Log.d(“My log”, “Отличные оценки: $excellentArray”)
}
for((index, name) in nameArray.withIndex()){
when(gradeArray[index]){
in bad -> badArray.add(“Плохие оценки: Ученик: $name –
${gradeArray[index]}”)
in normal -> normalArray.add(“Нормальные оценки: Ученик: $name –
${gradeArray[index]}”)
in nice -> niceArray.add(“Хорошие оценки: Ученик: $name –
${gradeArray[index]}”)
excellent -> excellentArray.add(“Отличные оценки: Ученик: $name –
${gradeArray[index]}”)
}
}
badArray.forEach {
Log.d(“LogProgram”, it)
}
normalArray.forEach {
Log.d(“LogProgram”, it)
}
niceArray.forEach {
Log.d(“LogProgram”, it)
}
excellentArray.forEach {
Log.d(“LogProgram”, it)
}
for ((index, name) in nameArray.withIndex()) {
when (gradeArray[index]) {
in bad -> badArray.add(“Плохие оценки: Ученик $name -> ${gradeArray[index]}”)
in normal -> normalArray.add(“Нормальные оценки: Ученик $name -> ${gradeArray[index]}”)
in nice -> niceArray.add(“Хорошие: Ученик $name -> ${gradeArray[index]}”)
excellent -> excellentArray.add(“Отличные оценки: Ученик $name -> ${gradeArray[index]}”)
}
}
badArray.forEach{Log.d(“MyLog”, “$it”)}
normalArray.forEach{Log.d(“MyLog”, “$it”)}
niceArray.forEach{Log.d(“MyLog”, “$it”)}
excellentArray.forEach{Log.d(“MyLog”, “$it”)}
почему-то ругается на in в excellent…
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
for((i,grade) in gradeArray.withIndex()){
when(grade) {
in bad -> badArray.add(“Плохие оценки: Ученик: ${nameArray[i]} – $grade”)
in normal -> normalArray.add(“Нормальные оценки: Ученик: ${nameArray[i]} – $grade”)
in nice -> niceArray.add(“Хорошие оценки: Ученик: ${nameArray[i]} – $grade”)
in excellent -> excellentArray.add(“Отличные оценки: Ученик: ${nameArray[i]} – $grade”)
}
}
badArray.forEach {Log.d(“MyLog”,”$it”)}
normalArray.forEach {Log.d(“MyLog”, “$it”)}
niceArray.forEach {Log.d(“MyLog”, “$it”)}
excellentArray.forEach {Log.d(“MyLog”, “$it”)}
}
вот я балбес. это же не интервал… in не нужен
//добавила от себя arrayList
var listStr = arrayListOf()
…
override fun onCreate(savedInstanceState: Bundle?) {
…
for((index,name) in nameArray.withIndex()){
when(gradeArray[index]){
in bad -> badArray.add(“Плохие оценки: Ученик: $name – ${gradeArray[index]}”)
in normal -> normalArray.add(“Нормальные оценки: Ученик: $name – ${gradeArray[index]}”)
in nice -> niceArray.add(“Хорошие оценки: Ученик: $name – ${gradeArray[index]}”)
excellent -> excellentArray.add(“Отличные оценки: Ученик: $name – ${gradeArray[index]}”)
}
}
listStr.addAll(badArray)
listStr.addAll(normalArray)
listStr.addAll(niceArray)
listStr.addAll(excellentArray)
for(i in 0 until listStr.size ){
Log.d(“MyLog”, “${listStr[i]}”)
}
…
}
for ((grade, name) in nameArray.withIndex())
{
if (gradeArray[grade] in bad)
{
badArray.add(“Плохие оценки: Ученик: ${nameArray[grade]} – ${gradeArray[grade]}”)
}
if (gradeArray[grade] in normal)
{
normalArray.add(“Нормальные оценки: Ученик: ${nameArray[grade]} – ${gradeArray[grade]}”)
}
if (gradeArray[grade] in nice)
{
niceArray.add(“Хорошие оценки: Ученик: ${nameArray[grade]} – ${gradeArray[grade]}”)
}
if (gradeArray[grade] == excellent)
{
excellentArray.add(“Отличные оценки: Ученик: ${nameArray[grade]} – ${gradeArray[grade]}”)
}
}
badArray.forEach {Log.d(“MyLog”, “$it”)}
normalArray.forEach {Log.d(“MyLog”, “$it”)}
niceArray.forEach {Log.d(“MyLog”, “$it”)}
excellentArray.forEach {Log.d(“MyLog”, “$it”)}
Извиняюсь, что без логов делал, т.к. не в AndroidStudio делал:
for(i in gradeArray.indices) {
for(j in nameArray.indices) {
if(i == j && gradeArray[i] in bad) {
badArray.add(“Плохие оценки: Ученик: ${nameArray[j]} – ${gradeArray[i]}”)
}
else if(i == j && gradeArray[i] in normal) {
normalArray.add(“Нормальные оценки оценки: Ученик: ${nameArray[j]} – ${gradeArray[i]}”)
}
else if(i == j && gradeArray[i] in nice ) {
niceArray.add(“Хорошие оценки оценки: Ученик: ${nameArray[j]} – ${gradeArray[i]}”)
}
else if(i == j && gradeArray[i] == excellent) {
excellentArray.add(“Отличные оценки оценки: Ученик: ${nameArray[j]} – ${gradeArray[i]}”)
}
}
}
badArray.forEach{
println(it)
}
normalArray.forEach{
println(it)
}
niceArray.forEach{
println(it)
}
excellentArray.forEach{
println(it)
}
// Цикл для распределения учеников по категориям
for ((index, grade) in gradeArray.withIndex()) {
when {
grade in bad -> badArray.add(“Ученик: ${nameArray[index]} – $grade”)
grade in normal -> normalArray.add(“Ученик: ${nameArray[index]} – $grade”)
grade in nice -> niceArray.add(“Ученик: ${nameArray[index]} – $grade”)
grade == excellent -> excellentArray.add(“Ученик: ${nameArray[index]} – $grade”)
}
}
// Вывод информации в лог
badArray.forEach { Log.d(“myInf”, “Плохие оценки: $it”) }
normalArray.forEach { Log.d(“myInf”, “Нормальные оценки: $it”) }
niceArray.forEach { Log.d(“myInf”, “Хорошие оценки: $it”) }
excellentArray.forEach { Log.d(“myInf”, “Отличные оценки: $it”) }
}
}
сначала сделал просто чтобы было 4 смс в логах (плохие оценки: и 2 ученика там) и т.д. потом перечитал задание и увидел что вывод другой проситься, конкретно под каждого отдельное смс, короче немного дурную работу сделал
Сделал 2 вариантами, первый через фор выводил результат, и когда тут смотрел, вспомнил что можно выводить сразу из массива badArray.forEach и этот вариант мне кажется проще. свой прошлый закоментил.
+ попробовал немного разные варианты вывода.
for((id, name) in nameArray.withIndex()){
var grade: Int = gradeArray[id]
when(grade) {
in bad -> badArray.add(“Плохие оценки: Ученик: ${name} – ${gradeArray[id]}”)
in normal -> normalArray.add(“Нормальные оценки: Ученик: ${name} – ${gradeArray[id]}”)
excellent -> excellentArray.add(“Нормальные оценки: Ученик: ${name} – ${gradeArray[id]}”)
7, 8, 9 -> niceArray.add(“Хорошие оценки: Ученик: ${name} – ${gradeArray[id]}”)
}
}
badArray.forEach {Log.d(“MyLog”, “$it”)}
normalArray.forEach {Log.d(“MyLog”, “$it”)}
niceArray.forEach {Log.d(“MyLog”, “$it”)}
excellentArray.forEach {Log.d(“MyLog”, “$it”)}
/*for (i in badArray){Log.d(“MyLog”, “$i”)}
for (i in normalArray){Log.d(“MyLog”, “$i”)}
for (i in niceArray){Log.d(“MyLog”, “$i”)}
for (i in excellentArray){Log.d(“MyLog”, “$i”)}
*/