Programmieren lernen

a=[]
# Definition der Ziffern von 0 - 9
a.append('abcefg')
a.append('cf')
a.append('acdeg')
a.append('acdfg')
a.append('bcdf')
a.append('abdfg')
a.append('abdefg')
a.append('acf')
a.append('abcdefg')
a.append('abcdfg')


def kommtVor(z,c):
    if a[z].rfind(c) == -1:
        return False
    return True

def welcheKommenVor(z):
    return a[z]

#Test alle Ziffern
for i in range(10):
    print welcheKommenVor(i)


print kommtVor(4,'a')
print kommtVor(5,'d')
                

/**
 * Siebensegment Dispalays.
 * Diese Lösung ist nicht optimal permormant,
 * dafür allgemein verständlich.
 * Musterlösung: Knuth: "The Art of Computer Programming".
 * 
 * @author Philipp Gressly (phi AT gressly DOT ch)
 */
public class SiebenSegmentDisplays {

  String[] segmente =
  { 
    /* 0: */ "abcefg",
    /* 1: */ "cf",
    /* 2: */ "acdeg",
    /* 3: */ "acdfg",
    /* 4: */ "bcdf",
    /* 5: */ "abdfg", 
    /* 6: */ "abdefg",  
    /* 7: */ "acf",  
    /* 8: */ "abcdefg", 
    /* 9: */ "abcdfg" 
  };
    
  boolean kommtVor(int ziffer, char segment) {
    int zeichenPosition;
    zeichenPosition = segmente[ziffer].indexOf(segment);
    return zeichenPosition >= 0;
  }
    
  String welcheKommenVor(int ziffer) {
    return segmente[ziffer];
  }
    
}  // end of class SiebenSegmentDisplays
                

import static org.junit.Assert.*;

import org.junit.Test;

/**
 * @author Philipp Gressly (phi AT gressly DOT ch)
 */
public class Test7Segmente {
  SiebenSegmentDisplay ssd = new SegmenteImplementation();
  
  @Test
  public void kommtVorZiffer2() {
      assertTrue (ssd.kommtVor(2, 'a'));
      assertFalse(ssd.kommtVor(2, 'b'));
      assertTrue (ssd.kommtVor(2, 'c'));
      // ...
  }
  @Test
  public void kommtVorZiffer3() {
      assertTrue (ssd.kommtVor(3, 'a'));
      assertFalse(ssd.kommtVor(3, 'b'));
      assertTrue (ssd.kommtVor(3, 'c'));
      // ...
  }
  
} // end of class Test7Segmente

/************************************************/
public interface SiebenSegmentDisplay {
    
  boolean        kommtVor(int ziffer, char segment);
  String  welcheKommenVor(int ziffer);
  
} // end of interface SiebenSegmentDisplay
/***********************************************/
/**
 * Implementation 7 Segment Dispaly mit Maskierung
 */
public class SegmenteImplementation implements SiebenSegmentDisplay {

    int A =  1;
    int B =  2;
    int C =  4;
    int D =  8;
    int E = 16;
    int F = 32;
    int G = 64;
    
    int[] segmente = {A, B, C, D, E, F, G};
    
    int[] ziffern = {
        /* 0 */ A + B + C + E + F + G,
        /* 1 */ C + F,
        /* 2 */ A + C + D + E + G,
        /* 3 */ A + C + D + F + G,
        /* 4 */ B + C + D + F,
        /* 5 */ A + B + D + F + G,
        /* 6 */ A + B + D + E + F + G,
        /* 7 */ A + C + F,
        /* 8 */ A + B + C + D + E + F + G,
        /* 9 */ A + B + C + D + F + G
    };
    
    /* overriden */
    @Override
    public boolean kommtVor(int ziffer, char segment) {
        int segmentMaske = segmente[segment - 'a'];
        return (ziffern[ziffer] & segmentMaske)
                == segmentMaske;
    }

    /* overriden */
    @Override
    public String welcheKommenVor(int ziffer) {
        String result = "";
        for(char c = 'a'; c <= 'g'; c++) {
          if(kommtVor(ziffer, c)) {
            result += c;      
          }
        }
        return result;
    }

   
}
 // end of class SegmenteImplementation

                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

let display = [
  'abcefg',    // 0
  'cf',        // 1
  'acdeg',     // 2
  'acdfg',     // 3
  'bcdf',      // 4
  'abdfg',     // 5
  'abdefg',    // 6
  'acf',       // 7
  'abcdefg',   // 8
  'abcdfg',    // 9
];

// kommt vor
function displayContains(digit, segment) {
  return display[digit].includes(segment)
};

// welche kommen vor
function necessarySegments(digit) {
  return display[digit];
}

// leuchtkraft
function getLuminosity(digit) {
  return display[digit].length;
}

// ausgabe
console.log(displayContains(2, 'd'));
console.log(necessarySegments(7));
console.log(getLuminosity(8));
console.log(getLuminosity(1));                               // lissalanda@gmx.at

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

// NET 6.x | C# 10.x | VS-2022

var lstSegments = new List<string> { "abcefg", "cf", "acdeg", "acdfg", "bcdf", "abdfg", "abdefg", "acf", "abcdefg", "abcdfg", "" };

string GetSegments(int n) => lstSegments[n is < 0 or > 9 ? 10 : n];
bool IsSegmentInNumber(int n, char c) => lstSegments[n is < 0 or > 9 ? 10 : n].Contains(c);

Console.WriteLine(GetSegments(3));
Console.WriteLine(IsSegmentInNumber(2, 'f'));
                

Lösung von: Jens Kelm (@JKooP)

// C++ 14 | VS-2022
#include <iostream>

int main() {
    const std::string segments[]{ "abcefg", "cf", "acdeg", "acdfg", "bcdf", "abdfg", "abdefg", "acf", "abcdefg", "abcdfg", "" };
    
    const auto get_segments{ [&](size_t n) noexcept { return segments[n < 0 || n > 9 ? 10 : n]; } };
    const auto is_segment_in_number{ [&](size_t n, char c) noexcept { return std::find(std::begin(segments[n]), std::end(segments[n]), c) != std::end(segments[n]);} };
   
    std::cout << get_segments(3) << "\n";
    std::cout << (is_segment_in_number(1, 'f') ? "true" : "false");
}
                

Lösung von: Jens Kelm (@JKooP)

' VBA

Function GetSegments(arr, n%)
    GetSegments = arr(IIf(n < 0 Or n > 9, 10, n))
End Function

Function IsSegmentInNumber(arr, n%, c$)
    IsSegmentInNumber = InStr(arr(IIf(n < 0 Or n > 9, 10, n)), c) > 0
End Function

Sub Main()
    arr = Array("abcefg", "cf", "acdeg", "acdfg", "bcdf", "abdfg", "abdefg", "acf", "abcdefg", "abcdfg", "")
    Debug.Print GetSegments(arr, 3)
    Debug.Print IsSegmentInNumber(arr, 2, "f")
End Sub

                

Lösung von: Jens Kelm (@JKooP)