Практика урок 21.

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)

}
}

51 комментарий для “Практика урок 21.”

  1. badArray.forEach {Log.d(“MyLog”, it)}
    normalArray.forEach {Log.d(“MyLog”, it)}
    normalArray.forEach {Log.d(“MyLog”, it)}
    excellentArray.forEach {Log.d(“MyLog”, it)}

  2. 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”)}

  3. 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”)}

  4. 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)}

  5. 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”)
    }

  6. 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”)
    )

  7. 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”)
    }

  8. У меня что самый гигантский код получился?
    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]}”)}

  9. //формируем массивы
    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]}”)

  10. 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”)}

  11. 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)
    }
    }

  12. 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”) }

  13. 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)}

  14. Оставлю свой след в истории!

    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)
    }

  15. 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 = ” / “)}”)

  16. 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”)
    }

    }

  17. Что то я немного намудрил… но тоже работает
    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]}”)
    }
    }
    }
    }

  18. Я не совсем понял зачем мы их по массивам раскидываем, если вывести можно просто сравнить и сразу вывести.
    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]}”)

    }

  19. Моё примитивнейшее решение, в стиле индуса, наверное. Пришлось наваять переменных, ибо без них крашилось. Но зато без всяких незнакомых на данном этапе конструкций, как у комментаторов выше, типа “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”) }
    }
    }

    1. Невнимательно прочитал задание и сделал фигню. Вот итоговый код:
      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”)}
      }

  20. 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
    }
    }

  21. совсем забыл про 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]}")
    }

  22. 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”)}

  23. 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]}”)
    }

  24. 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) }

  25. 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”)}

  26. Не могу понять, почему не работает, лог показывает только Антона((

    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])
    }
    }

  27. 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)
    }

  28. Вставлю свои 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”)
    }

  29. Для тех, кто практику делает в 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)
    }
    }

  30. Без логов – вывод на 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]}”)

    }

  31. 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”)

    }

  32. 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)
    }

  33. 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”)}

  34. почему-то ругается на 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”)}
    }

  35. //добавила от себя 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]}”)
    }

    }

  36. 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”)}

  37. Извиняюсь, что без логов делал, т.к. не в 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)
    }

  38. // Цикл для распределения учеников по категориям
    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”) }
    }
    }

    1. сначала сделал просто чтобы было 4 смс в логах (плохие оценки: и 2 ученика там) и т.д. потом перечитал задание и увидел что вывод другой проситься, конкретно под каждого отдельное смс, короче немного дурную работу сделал

  39. Сделал 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”)}
    */

Добавить комментарий

Ваш адрес email не будет опубликован.