Задача

[StringTheoryPracticist]

Винаги когато А е вярно, В също е вярно.

Кои от следните са винаги верни?

1. Знаем, че А е вярно. Следователно В трябва да е вярно.
2. Знаем, че А е грешно. Следователно В трябва да е грешно.
3. Знаем, че В е грешно. Следователно А трябва да е грешно.
4. Знаем, че В е вярно. Следователно А трябва да е вярно.

Който познае получава онлайн прегръдка / потупване по рамото.

[MaLyKoLiU]

1 и 3

[LadyDi]

1 и 3

+

[Mary_Jane_69]

1 и 4
и 2 и 3

ЗАРЕ ЗВЪННИ МИ ПО ВАЙБАР

[StringTheoryPracticist]

if(A===true && B===true){
return 1;
}

следователно верни са само 1 и 4

програмата може да се съкрати на

{ return A && B; }

Но това не помага за задачата, модела ти е грешен. Можеш да я решиш с boolean algebra и truth tables, но това би било чийтинг, тъй като замисъла на задачата е да го решиш сам, без употребата на специално научени техники. Друг вид чийтинг би бил следната функция (кода е в Scala):

  case class State(val A: Boolean, val B: Boolean)
  val stateSpace: Set[State] = Set(State(true, true), State(true, false), State(false, true), State(false, false))
  // Logical rule: if A is true then B must be true
  def isNotIllogical(s: State): Boolean = {
    if (s.A == true) s.B == true
    else true // if A is not true, the logical rule cannot possibly be violated
  }
  // Input: given variable, variable's position (0 = A, 1 = B), resulting state
  def deduce(given: Boolean, givenPos: Int, asserted: State): Boolean = {
    // List of states where the starting condition is kept
    val initialStates: Set[State] = stateSpace.filter(_.productElement(givenPos) == given)  // x.productElement(0) <=> x.A; x.productElement(1) <=> x.B
    // The states which also keep the logical rule
    val logicalStates: Set[State] = initialStates.filter(isNotIllogical(_))
    // True if the asserted state is THE ONLY logical state
    logicalStates.size == 1 && logicalStates.contains(asserted)
  }

  val A = 0; val B = 1
  val answers = List(
                     deduce(true, A, State(true, true)),
                     deduce(false, A, State(false, false)),
                     deduce(false, B, State(false, false)),
                     deduce(true, B, State(true, true))
  )
  for (n <- 1 to 4) println("Answer " + n + " is " + answers(n-1))

Не е идеален код за реална, maintainable и extensible апликация; но идеята беше да е четим. Filter функцията връща сублист който пасва условието, например:

List(1, 2, 3, 4).filter({x => x.isEven}) // връща List(2, 4)
еквивалентно е
List(1, 2, 3, 4).filter(_.isEven)

Мисля че останалото се подразбира достатъчно, ако не - питай ме.

Ако имаш инсталиран Scala можеш да пуснеш кода и в действителност дава правилния отговор :Р

Edit: има и много по-кратко решение, написах горното така за да е максимално четимо (въпреки че като се замисля, долното май също е много разбираемо). Ето вариант от 3 реда код, който все още е задоволително четим (включил съм и приложението на функцията). Тук започвам с възможните състояния на A, B които спазват логическото правило, от тях взимам тези при които дадената буква съвпада, накрая проверявам дали е само едно състояние и е състоянието което пасва на извода.

  val validStateSpace = Set((true, true), (false, true), (false, false))
  def deduce(given: Boolean, givenPos: Int, assertedState: (Boolean, Boolean)) =
    ( validStateSpace.filter(_.productElement(givenPos) == given) ) == Set(assertedState)

  val answers = List( deduce(true, 0, (true, true)),
                      deduce(false, 0, (false, false)),
                      deduce(false, 1, (false, false)),
                      deduce(true, 1, (true, true)) )
  for (n <- 1 to 4) println("Answer " + n + " is " + answers(n-1))

Бях забравил колко много обичам Scala.