spring integration TCP TLS client authentication - spring

I need to create a TCP/TLS Server that does Client-authenticated TLS handshake.
i am using Spring Boot and tcp-inbound-gateway to accept TCP connections.
Here is the configuration:
<context:component-scan base-package="com.mycompany"/>
<int-ip:tcp-connection-factory id="crLfServer"
deserializer="myDeserializer"
serializer="serverSerializer"
single-use="false"
type="server"
ssl-context-support="mySslContext"
port="${local.server.port}"/>
<int-ip:tcp-inbound-gateway id="gatewayCrLf"
connection-factory="crLfServer"
request-channel="serverInChannel"
reply-channel="serverOutChannel"
error-channel="errorChannel"/>
<int:channel id="serverOutChannel"/>
<int:channel id="serverInChannel"/>
<int:service-activator input-channel="serverInChannel"
ref="transferService"
method="printService"/>
The SSLContext:
#Component
public class MySslContext extends DefaultTcpSSLContextSupport {
public MySslContext(
#Value("serverKeyStore.key") String keyStore,
#Value("serverOnlyTS.key") String trustStore,
#Value("123456") String keyStorePassword,
#Value("123456") String trustStorePassword) {
super(keyStore, trustStore, keyStorePassword, trustStorePassword);
}
}
The TransferService does a very simple job:
public Message<byte[]> printService(Message<byte[]> m){
log.info("Message received from client: " + m.getPayload());
return m;
}
On the other side, i configured a simple client that communicates with my server:
<int-ip:tcp-connection-factory
id="clientCF"
type="client"
host="127.0.0.1"
port="4444"
single-use="false"
lookup-host="false"
serializer="directSerializer"
ssl-context-support="myClientSslContext"/>
<bean id="myClientSslContext" class="org.springframework.integration.ip.tcp.connection.DefaultTcpSSLContextSupport">
<constructor-arg index="0" value="clientKeyStore.key"/>
<constructor-arg index="1" value="serverOnlyTS.key"/>
<constructor-arg index="2" value="123456"/>
<constructor-arg index="3" value="123456"/>
</bean>
<bean id="directSerializer" class="com.mycompany.DirectSerializer">
<constructor-arg value="clientSer"/>
</bean>
<int-ip:tcp-outbound-gateway id="outGateway"
request-channel="clientOutChannel"
reply-channel="clientInChannel"
connection-factory="clientCF"/>
<int:channel id="clientOutChannel"/>
<int:channel id="clientInChannel"/>
The client starts with this code:
public class Main {
public static void main(String[] args) throws InterruptedException {
byte[] message = {11,11,11,11,11,11,11,11,11,11};
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("ssl-client.xml");
DirectChannel c= (DirectChannel) context.getBean("clientOutChannel");
c.send(MessageBuilder.withPayload(message).build());
}
}
The serverKeyStore.key is imported to a truststore serverOnlyTS.key (both client and server uses this truststore), the clientKeyStore.key is not imported to any truststore.
According to this article: How to setup TLS Server to authenticate client in spring integration?,
i expect that my server will do a client authentication and accept only connections that uses serverKeyStore.key.
In fact, when i run the client, my server recieves the message correctly and i see this output: (-Djavax.net.debug=ssl)
Allow unsafe renegotiation: false
Allow legacy hello messages: true
Is initial handshake: true
Is secure renegotiation: false
pool-1-thread-1, setSoTimeout(0) called
Ignoring unavailable cipher suite: TLS_DHE_DSS_WITH_AES_256_GCM_SHA384
........
pool-1-thread-3, READ: TLSv1.2 Handshake, length = 193
*** ClientHello, TLSv1.2
RandomCookie: GMT: 1482858633 bytes = { 81, 115, 166, 218, 194, 111, 29, 83, 96, 23, 240, 122, 118, 11, 1, 62, 52, 12, 102, 69, 151, 215, 180, 42, 76, 192, 48, 197 }
Session ID: {}
Cipher Suites: [TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, TLS_RSA_WITH_AES_128_CBC_SHA256, TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256, TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256, TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, TLS_DHE_DSS_WITH_AES_128_CBC_SHA256, TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, TLS_RSA_WITH_AES_128_CBC_SHA, TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA, TLS_ECDH_RSA_WITH_AES_128_CBC_SHA, TLS_DHE_RSA_WITH_AES_128_CBC_SHA, TLS_DHE_DSS_WITH_AES_128_CBC_SHA, TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, TLS_RSA_WITH_AES_128_GCM_SHA256, TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256, TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256, TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, TLS_DHE_DSS_WITH_AES_128_GCM_SHA256, TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA, TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, SSL_RSA_WITH_3DES_EDE_CBC_SHA, TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA, TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA, SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA, SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA, TLS_EMPTY_RENEGOTIATION_INFO_SCSV]
Compression Methods: { 0 }
Extension elliptic_curves, curve names: {secp256r1, sect163k1, sect163r2, secp192r1, secp224r1, sect233k1, sect233r1, sect283k1, sect283r1, secp384r1, sect409k1, sect409r1, secp521r1, sect571k1, sect571r1, secp160k1, secp160r1, secp160r2, sect163r1, secp192k1, sect193r1, sect193r2, secp224k1, sect239k1, secp256k1}
Extension ec_point_formats, formats: [uncompressed]
Extension signature_algorithms, signature_algorithms: SHA512withECDSA, SHA512withRSA, SHA384withECDSA, SHA384withRSA, SHA256withECDSA, SHA256withRSA, SHA256withDSA, SHA1withECDSA, SHA1withRSA, SHA1withDSA, MD5withRSA
***
%% Initialized: [Session-2, SSL_NULL_WITH_NULL_NULL]
%% Negotiating: [Session-2, TLS_DHE_DSS_WITH_AES_128_CBC_SHA256]
*** ServerHello, TLSv1.2
RandomCookie: GMT: 1482858633 bytes = { 242, 158, 132, 149, 150, 9, 60, 231, 104, 29, 171, 220, 15, 164, 169, 111, 78, 8, 179, 209, 168, 190, 62, 220, 53, 119, 152, 91 }
Session ID: {88, 99, 161, 137, 97, 86, 192, 141, 13, 111, 100, 231, 192, 248, 131, 25, 159, 39, 121, 17, 133, 96, 208, 197, 116, 214, 200, 49, 171, 203, 172, 99}
Cipher Suite: TLS_DHE_DSS_WITH_AES_128_CBC_SHA256
Compression Method: 0
Extension renegotiation_info, renegotiated_connection: <empty>
***
Cipher suite: TLS_DHE_DSS_WITH_AES_128_CBC_SHA256
*** Certificate chain
chain [0] = [
[
Version: V3
Subject: CN=gena j, OU=dev, O=cg, L=il, ST=il, C=il
Signature Algorithm: SHA1withDSA, OID = 1.2.840.10040.4.3
Key: Sun DSA Public Key
Parameters:DSA
p: fd7f5381 1d751229 52df4a9c 2eece4e7 f611b752 3cef4400 c31e3f80 b6512669
455d4022 51fb593d 8d58fabf c5f5ba30 f6cb9b55 6cd7813b 801d346f f26660b7
6b9950a5 a49f9fe8 047b1022 c24fbba9 d7feb7c6 1bf83b57 e7c6a8a6 150f04fb
83f6d3c5 1ec30235 54135a16 9132f675 f3ae2b61 d72aeff2 2203199d d14801c7
q: 9760508f 15230bcc b292b982 a2eb840b f0581cf5
g: f7e1a085 d69b3dde cbbcab5c 36b857b9 7994afbb fa3aea82 f9574c0b 3d078267
5159578e bad4594f e6710710 8180b449 167123e8 4c281613 b7cf0932 8cc8a6e1
3c167a8b 547c8d28 e0a3ae1e 2bb3a675 916ea37f 0bfa2135 62f1fb62 7a01243b
cca4f1be a8519089 a883dfe1 5ae59f06 928b665e 807b5525 64014c3b fecf492a
y:
09356efb 5c421633 dc73eeee 7389d573 20a54fed eba1cc95 c2c451da 38a8ec10
04c80b53 57c712fa 536b05aa 3f497153 58bb8e70 691d4cd6 3d9ab0e1 f14a005d
16c4ad2b dadf91ff fbfcae4f dadcbede 35e90b9f a8e37ec6 e28f78f5 269fee9e
8cb96fa5 d36b3ac3 059195c7 0a586484 6fc84493 764f27ce e127192d 252fd94a
Validity: [From: Wed Dec 28 11:33:01 IST 2016,
To: Tue Mar 28 12:33:01 IDT 2017]
Issuer: CN=gena j, OU=dev, O=cg, L=il, ST=il, C=il
SerialNumber: [ 6c326fb1]
Certificate Extensions: 1
[1]: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: A1 84 23 95 00 CA 92 06 AC DB E7 E9 43 39 48 7E ..#.........C9H.
0010: 9F 1B A2 1E ....
]
]
]
Algorithm: [SHA1withDSA]
Signature:
0000: 30 2D 02 14 2E FB 00 B3 62 8F 3A C3 7E C3 EC 18 0-......b.:.....
0010: 6A 67 B2 97 A2 C9 62 25 02 15 00 92 F8 2E 97 3E jg....b%.......>
0020: 29 1F 3B 5D 8A 7A DE D4 5D 76 09 56 35 53 21 ).;].z..]v.V5S!
]
***
*** Diffie-Hellman ServerKeyExchange
DH Modulus: { 255, 255, 255, 255, 255, 255, 255, 255, 201, 15, 218, 162, 33, 104, 194, 52, 196, 198, 98, 139, 128, 220, 28, 209, 41, 2, 78, 8, 138, 103, 204, 116, 2, 11, 190, 166, 59, 19, 155, 34, 81, 74, 8, 121, 142, 52, 4, 221, 239, 149, 25, 179, 205, 58, 67, 27, 48, 43, 10, 109, 242, 95, 20, 55, 79, 225, 53, 109, 109, 81, 194, 69, 228, 133, 181, 118, 98, 94, 126, 198, 244, 76, 66, 233, 166, 55, 237, 107, 11, 255, 92, 182, 244, 6, 183, 237, 238, 56, 107, 251, 90, 137, 159, 165, 174, 159, 36, 17, 124, 75, 31, 230, 73, 40, 102, 81, 236, 230, 83, 129, 255, 255, 255, 255, 255, 255, 255, 255 }
DH Base: { 2 }
Server DH Public Key: { 76, 1, 47, 15, 147, 255, 144, 196, 90, 71, 173, 116, 138, 121, 159, 38, 249, 6, 152, 219, 59, 126, 193, 34, 64, 24, 25, 172, 100, 252, 76, 120, 215, 194, 111, 10, 106, 161, 31, 221, 17, 10, 119, 13, 224, 212, 69, 169, 14, 139, 241, 129, 171, 126, 55, 165, 254, 5, 22, 216, 16, 119, 65, 36, 235, 223, 41, 58, 112, 71, 212, 137, 185, 126, 226, 45, 26, 216, 150, 28, 145, 203, 73, 4, 188, 9, 173, 124, 166, 50, 39, 99, 40, 105, 13, 16, 228, 140, 99, 143, 228, 167, 12, 171, 87, 50, 205, 193, 223, 3, 113, 43, 27, 87, 63, 45, 210, 186, 36, 102, 164, 223, 181, 254, 150, 56, 67, 19 }
Signature Algorithm SHA256withDSA
Signed with a DSA or RSA public key
*** ServerHelloDone
pool-1-thread-3, WRITE: TLSv1.2 Handshake, length = 1188
pool-1-thread-3, READ: TLSv1.2 Handshake, length = 134
*** ClientKeyExchange, DH
DH Public key: { 195, 132, 198, 83, 122, 44, 17, 51, 121, 11, 125, 243, 215, 195, 28, 209, 241, 218, 233, 233, 40, 141, 63, 184, 104, 159, 85, 29, 70, 15, 37, 14, 236, 143, 255, 67, 96, 0, 23, 115, 109, 22, 235, 32, 215, 28, 116, 15, 206, 56, 249, 72, 246, 181, 203, 65, 107, 205, 20, 240, 150, 121, 55, 59, 154, 62, 202, 31, 55, 232, 235, 167, 45, 155, 232, 62, 205, 203, 188, 164, 213, 202, 81, 114, 202, 124, 160, 28, 252, 229, 225, 87, 47, 225, 111, 57, 163, 187, 152, 176, 200, 249, 26, 103, 4, 243, 204, 60, 146, 28, 175, 196, 5, 47, 107, 216, 18, 28, 36, 202, 136, 219, 118, 96, 53, 218, 24, 209 }
SESSION KEYGEN:
PreMaster Secret:
0000: E6 82 09 78 D2 9D 3C F3 60 57 97 DD 18 32 E5 92 ...x..<.`W...2..
0010: BC A6 CC 62 90 F3 D6 1E 23 0B 3C CE 10 92 9C 11 ...b....#.<.....
0020: DB AF B6 89 20 72 DB D6 8E F2 26 59 38 B1 67 E9 .... r....&Y8.g.
0030: FF E3 97 8F 55 1E 32 A5 A7 BB 62 14 E9 67 0E 5F ....U.2...b..g._
0040: DF C4 98 5C 29 E3 02 DB 1F 57 93 5C 9B 43 26 8D ...\)....W.\.C&.
0050: E3 06 D6 06 61 7D 19 99 B5 CE C8 D2 53 74 82 0C ....a.......St..
0060: 3E 44 EC B0 D4 71 F2 55 73 D3 66 B2 F3 AB 37 AE >D...q.Us.f...7.
0070: 18 01 8F BC FE 54 4F 8D 6F AD 59 FD 87 E5 5A 72 .....TO.o.Y...Zr
CONNECTION KEYGEN:
Client Nonce:
0000: 58 63 A1 89 51 73 A6 DA C2 6F 1D 53 60 17 F0 7A Xc..Qs...o.S`..z
0010: 76 0B 01 3E 34 0C 66 45 97 D7 B4 2A 4C C0 30 C5 v..>4.fE...*L.0.
Server Nonce:
0000: 58 63 A1 89 F2 9E 84 95 96 09 3C E7 68 1D AB DC Xc........<.h...
0010: 0F A4 A9 6F 4E 08 B3 D1 A8 BE 3E DC 35 77 98 5B ...oN.....>.5w.[
Master Secret:
0000: C5 89 9E 61 C3 94 89 72 8B 16 34 05 9C 54 69 D2 ...a...r..4..Ti.
0010: DE 02 50 93 98 98 42 2F B5 A6 D7 90 11 AD B2 AE ..P...B/........
0020: 9A 76 6E 48 B2 6B 1B BC 94 42 92 FC 59 58 6F BA .vnH.k...B..YXo.
Client MAC write Secret:
0000: 5F 43 41 51 5C D2 F1 4C 5A 33 4B 0E F8 A4 09 DF _CAQ\..LZ3K.....
0010: 7B 3A 83 EA 62 23 C1 F2 38 AB FD 92 F1 F3 33 74 .:..b#..8.....3t
Server MAC write Secret:
0000: B8 14 DF 6F AC AA 29 34 F6 68 6E 4F 76 2A 94 B2 ...o..)4.hnOv*..
0010: CB CB F5 66 EE 5F 3F 8F AF E4 AA 8A 29 C2 04 4F ...f._?.....)..O
Client write key:
0000: 39 A7 98 73 C7 49 0E D5 1E 92 45 C7 9F DE D7 91 9..s.I....E.....
Server write key:
0000: BE AC 70 EF 2E 58 72 42 71 38 89 DF F1 AF 15 62 ..p..XrBq8.....b
... no IV derived for this protocol
pool-1-thread-3, READ: TLSv1.2 Change Cipher Spec, length = 1
pool-1-thread-3, READ: TLSv1.2 Handshake, length = 80
*** Finished
verify_data: { 27, 30, 80, 199, 171, 151, 17, 231, 188, 152, 123, 58 }
***
pool-1-thread-3, WRITE: TLSv1.2 Change Cipher Spec, length = 1
*** Finished
verify_data: { 231, 12, 206, 159, 3, 117, 192, 43, 195, 31, 193, 139 }
***
pool-1-thread-3, WRITE: TLSv1.2 Handshake, length = 80
%% Cached server session: [Session-2, TLS_DHE_DSS_WITH_AES_128_CBC_SHA256]
pool-1-thread-3, READ: TLSv1.2 Application Data, length = 64
28/12/16 13:27:05.397 [pool-1-thread-3] Message received from client: [B#66070151
I am new to TLS, but i think that i need to see ***CertificateRequest when the server does client authentication.
Any idea what i am missing out?

We could probably make this a little easier but you have to configure a socket-support instance to require client authentication.
When using java configuration, you can just inject it...
serverFactory.setTcpSocketSupport(new DefaultTcpSocketSupport() {
#Override
public void postProcessServerSocket(ServerSocket serverSocket) {
((SSLServerSocket) serverSocket).setNeedClientAuth(true);
}
});
When using XML configuration, you can create a subclass of DefaultTcpSocketSupport and pass a reference to a <bean/> of that class in the socket-support attribute on the server connection factory.
Documentation here.

Related

How To Serialize A Modified Go Packet Packet Into Real IP Packet

Why
I want to write a proxy server, proxy server changes IP/port of a packet and emits modified.
Attempt
package main
import (
"encoding/hex"
"github.com/google/gopacket"
"github.com/google/gopacket/layers"
"fmt"
"net"
)
func main() {
packetData := []byte{
69, 0, 0, 63, 64, 237, 64, 0, 64, 6, 74, 221, 192,
168, 1, 90, 52, 85, 184, 151, 141, 230, 0, 80,
174, 147, 86, 192, 18, 107, 243, 149, 128, 24,
0, 229, 92, 65, 0, 0, 1, 1, 8, 10, 22, 138, 85, 109,
48, 16, 32, 253, 49, 50, 51, 52, 53, 54, 55, 56,
57, 48, 10,
}
fmt.Println("Hex dump of real IP packet taken as input:\n")
fmt.Println(hex.Dump(packetData))
packet := gopacket.NewPacket(packetData, layers.LayerTypeIPv4, gopacket.Default)
if ipLayer := packet.Layer(layers.LayerTypeIPv4); ipLayer != nil {
ip := ipLayer.(*layers.IPv4)
dst := ip.DstIP.String()
src := ip.SrcIP.String()
if tcpLayer := packet.Layer(layers.LayerTypeTCP); tcpLayer != nil {
tcp := tcpLayer.(*layers.TCP)
dst = fmt.Sprintf("%s:%d", dst, tcp.DstPort)
src = fmt.Sprintf("%s:%d", src, tcp.SrcPort)
fmt.Printf("From %s to %s\n\n", src, dst)
ip.DstIP = net.ParseIP("8.8.8.8")
options := gopacket.SerializeOptions{
ComputeChecksums: true,
FixLengths: true,
}
newBuffer := gopacket.NewSerializeBuffer()
gopacket.SerializeLayers(newBuffer, options,
ip,
tcp,
)
outgoingPacket := newBuffer.Bytes()
fmt.Println("Hex dump of go packet serialization output:\n")
fmt.Println(hex.Dump(outgoingPacket))
}
}
}
Output
Hex dump of real IP packet taken as input:
00000000 45 00 00 3f 40 ed 40 00 40 06 4a dd c0 a8 01 5a |E..?#.#.#.J....Z|
00000010 34 55 b8 97 8d e6 00 50 ae 93 56 c0 12 6b f3 95 |4U.....P..V..k..|
00000020 80 18 00 e5 5c 41 00 00 01 01 08 0a 16 8a 55 6d |....\A........Um|
00000030 30 10 20 fd 31 32 33 34 35 36 37 38 39 30 0a |0. .1234567890.|
From 192.168.1.90:36326 to 52.85.184.151:80
Hex dump of go packet serialization output:
00000000 8d e6 00 50 ae 93 56 c0 12 6b f3 95 80 18 00 e5 |...P..V..k......|
00000010 00 00 00 00 01 01 08 0a 16 8a 55 6d 30 10 20 fd |..........Um0. .|
What's Wrong
Second hex dump must start with 45 (most IPv4 packets start with 45, where 4 is a version of the protocol). Second hexdump must be identical to the first in many details except one IP address that was changed, TCP checksum and size values. Second hex dump must contain payload 1234567890\n.
Similar Questions
How to use Golang to compose raw TCP packet (using gopacket) and send it via raw socket
Sending UDP packets with gopacket
Changing the IP address of a Gopacket and re-transmitting using raw sockets
First, always check returned errors — it's your feedback:
err := gopacket.SerializePacket(newBuffer, options, packet)
// OR
err := gopacket.SerializeLayers(newBuffer, options,
ip,
tcp,
)
// THEN
if err != nil {
panic(err)
}
From code above you will get: TCP/IP layer 4 checksum cannot be computed without network layer... call SetNetworkLayerForChecksum to set which layer to use
Then, the solution is to use tcp.SetNetworkLayerForChecksum(ip) and the final working code:
package main
import (
"encoding/hex"
"github.com/google/gopacket"
"github.com/google/gopacket/layers"
"fmt"
"net"
)
func main() {
packetData := []byte{
69, 0, 0, 63, 64, 237, 64, 0, 64, 6, 74, 221, 192,
168, 1, 90, 52, 85, 184, 151, 141, 230, 0, 80,
174, 147, 86, 192, 18, 107, 243, 149, 128, 24,
0, 229, 92, 65, 0, 0, 1, 1, 8, 10, 22, 138, 85, 109,
48, 16, 32, 253, 49, 50, 51, 52, 53, 54, 55, 56,
57, 48, 10,
}
fmt.Println("Hex dump of real IP packet taken as input:\n")
fmt.Println(hex.Dump(packetData))
packet := gopacket.NewPacket(packetData, layers.LayerTypeIPv4, gopacket.Default)
if ipLayer := packet.Layer(layers.LayerTypeIPv4); ipLayer != nil {
ip := ipLayer.(*layers.IPv4)
dst := ip.DstIP.String()
src := ip.SrcIP.String()
if tcpLayer := packet.Layer(layers.LayerTypeTCP); tcpLayer != nil {
tcp := tcpLayer.(*layers.TCP)
dst = fmt.Sprintf("%s:%d", dst, tcp.DstPort)
src = fmt.Sprintf("%s:%d", src, tcp.SrcPort)
fmt.Printf("From %s to %s\n\n", src, dst)
ip.DstIP = net.ParseIP("8.8.8.8")
options := gopacket.SerializeOptions{
ComputeChecksums: true,
FixLengths: true,
}
tcp.SetNetworkLayerForChecksum(ip)
newBuffer := gopacket.NewSerializeBuffer()
err := gopacket.SerializePacket(newBuffer, options, packet)
if err != nil {
panic(err)
}
outgoingPacket := newBuffer.Bytes()
fmt.Println("Hex dump of go packet serialization output:\n")
fmt.Println(hex.Dump(outgoingPacket))
}
}
}
Output
Hex dump of real IP packet taken as input:
00000000 45 00 00 3f 40 ed 40 00 40 06 4a dd c0 a8 01 5a |E..?#.#.#.J....Z|
00000010 34 55 b8 97 8d e6 00 50 ae 93 56 c0 12 6b f3 95 |4U.....P..V..k..|
00000020 80 18 00 e5 5c 41 00 00 01 01 08 0a 16 8a 55 6d |....\A........Um|
00000030 30 10 20 fd 31 32 33 34 35 36 37 38 39 30 0a |0. .1234567890.|
From 192.168.1.90:36326 to 52.85.184.151:80
Hex dump of go packet serialization output:
00000000 45 00 00 3f 40 ed 40 00 40 06 27 ba c0 a8 01 5a |E..?#.#.#.'....Z|
00000010 08 08 08 08 8d e6 00 50 ae 93 56 c0 12 6b f3 95 |.......P..V..k..|
00000020 80 18 00 e5 39 1e 00 00 01 01 08 0a 16 8a 55 6d |....9.........Um|
00000030 30 10 20 fd 31 32 33 34 35 36 37 38 39 30 0a |0. .1234567890.|
As you see 08 08 08 08 is a new IP and payload 1234567890\n is also preserved, IP packet starts with 45 as usual.

Row sum in PIVOT query

Please Help me i am trying to create pivot but not success.
query
select
t.g_no,
t.sz,
t.DT,
t.Qty
from gp123 t
Result
4480 46 4/24/2017 30
4480 42 4/24/2017 28
4480 40 4/24/2017 37
4480 44 4/24/2017 26
4480 50 4/24/2017 17
4480 48 4/24/2017 2
Required result
Gate Pass No. Date 40 42 44 46 48 50 Total
4480 24-Apr-17 37 28 26 30 2 17 140
4500 25-Apr-17 187 140 155 127 99 85 793
4537 25-Apr-17 141 97 139 172 141 159 849
4538 26-Apr-17 90 141 122 148 172 151 824
4542 26-Apr-17 1 60 118 63 32 3 277
Use the SUM() OVER () analytic function to get the total and then use PIVOT to convert the rows to columns:
SELECT *
FROM ( SELECT g_no AS "Gate Pass No.",
sz,
DT AS "Date",
Qty,
SUM( qty ) OVER ( PARTITION BY g_no, DT ) AS Total
FROM gp123
)
PIVOT ( SUM( qty ) FOR sz IN ( 40, 42, 44, 46, 48, 50 ) )
... or simply:
select g_no, dt, "40", "42", "44", "46", "48", "50",
"40" + "42" + "44" + "46" + "48" + "50" total
from gp123 t
pivot (sum(qty) for sz in (40, 42, 44, 46, 48, 50));

How i can improve the code?

I'm beginner in programming. Could i use two elements in golang for-loops? If you know answer, or material which i should read, please help me.
package main
import (
"fmt"
)
func main() {
x := []int{
48, 96, 86, 68,
57, 82, 63, 70,
37, 34, 83, 27,
19, 97, 9, 17,
}
for a := 0, b := 1; a++, b++ {
if x[a] > x[b] {
x = append(x[:1], x[1+1:]...)
fmt.Println("x[1+1:]x)", x)
} else {
x = append(x[:0], x[0+1:]...)
fmt.Println("x[0+1:]x)", x)
}
}
}
Yes, you can, although it's unnecessary in this case.
The syntax function fixes the syntax and other errors in your code so that your code runs and produces output. The idiom function rewrites your code in a more idiomatic form.
package main
import (
"fmt"
)
func syntax() {
x := []int{
48, 96, 86, 68,
57, 82, 63, 70,
37, 34, 83, 27,
19, 97, 9, 17,
}
for a, b := 0, 1; a < len(x) && b < len(x); a, b = a+1, b+1 {
if x[a] > x[b] {
x = append(x[:1], x[1+1:]...)
fmt.Println("x[1+1:]x)", x)
} else {
x = append(x[:0], x[0+1:]...)
fmt.Println("x[0+1:]x)", x)
}
}
}
func idiom() {
x := []int{
48, 96, 86, 68,
57, 82, 63, 70,
37, 34, 83, 27,
19, 97, 9, 17,
}
for i := 1; i < len(x); i++ {
if x[i-1] > x[i] {
x = append(x[:1], x[1+1:]...)
fmt.Println("x[1+1:]x)", x)
} else {
x = append(x[:0], x[0+1:]...)
fmt.Println("x[0+1:]x)", x)
}
}
}
func main() {
syntax()
fmt.Println()
idiom()
}
Output:
$ go run beginner.go
x[0+1:]x) [96 86 68 57 82 63 70 37 34 83 27 19 97 9 17]
x[1+1:]x) [96 68 57 82 63 70 37 34 83 27 19 97 9 17]
x[0+1:]x) [68 57 82 63 70 37 34 83 27 19 97 9 17]
x[0+1:]x) [57 82 63 70 37 34 83 27 19 97 9 17]
x[1+1:]x) [57 63 70 37 34 83 27 19 97 9 17]
x[1+1:]x) [57 70 37 34 83 27 19 97 9 17]
x[0+1:]x) [70 37 34 83 27 19 97 9 17]
x[0+1:]x) [37 34 83 27 19 97 9 17]
x[0+1:]x) [96 86 68 57 82 63 70 37 34 83 27 19 97 9 17]
x[1+1:]x) [96 68 57 82 63 70 37 34 83 27 19 97 9 17]
x[0+1:]x) [68 57 82 63 70 37 34 83 27 19 97 9 17]
x[0+1:]x) [57 82 63 70 37 34 83 27 19 97 9 17]
x[1+1:]x) [57 63 70 37 34 83 27 19 97 9 17]
x[1+1:]x) [57 70 37 34 83 27 19 97 9 17]
x[0+1:]x) [70 37 34 83 27 19 97 9 17]
x[0+1:]x) [37 34 83 27 19 97 9 17]
Follow the link to take A Tour of Go.

What are the mathematical/computational principles behind this game?

My kids have this fun game called Spot It! The game constraints (as best I can describe) are:
It is a deck of 55 cards
On each card are 8 unique pictures (i.e. a card can't have 2 of the same picture)
Given any 2 cards chosen from the deck, there is 1 and only 1 matching picture.
Matching pictures may be scaled differently on different cards but that is only to make the game harder (i.e. a small tree still matches a larger tree)
The principle of the game is: flip over 2 cards and whoever first picks the matching picture gets a point.
Here's a picture for clarification:
(Example: you can see from the bottom 2 cards above that the matching picture is the green dinosaur. Between the bottom-right and middle-right picture, it's a clown's head.)
I'm trying to understand the following:
What are the minimum number of different pictures required to meet these criteria and how would you determine this?
Using pseudocode (or Ruby), how would you generate 55 game cards from an array of N pictures (where N is the minimum number from question 1)?
Update:
Pictures do occur more than twice per deck (contrary to what some have surmised). See this picture of 3 cards, each with a lightning bolt:
Finite Projective Geometries
The axioms of projective (plane) geometry are slightly different than the Euclidean geometry:
Every two points have exactly one line that passes through them (this is the same).
Every two lines meet in exactly one point (this is a bit different from Euclid).
Now, add "finite" into the soup and you have the question:
Can we have a geometry with just 2 points? With 3 points? With 4? With 7?
There are still open questions regarding this problem but we do know this:
If there are geometries with Q points, then Q = n^2 + n + 1 and n is called the order of the geometry.
There are n+1 points in every line.
From every point, pass exactly n+1 lines.
Total number of lines is also Q.
And finally, if n is prime, then there does exists a geometry of order n.
What does that have to do with the puzzle, one may ask.
Put card instead of point and picture instead of line and the axioms become:
Every two cards have exactly one picture in common.
For every two pictures there is exactly one card that has both of them.
Now, lets take n=7 and we have the order-7 finite geometry with Q = 7^2 + 7 + 1 . That makes Q=57 lines (pictures) and Q=57 points (cards). I guess the puzzle makers decided that 55 is more round number than 57 and left 2 cards out.
We also get n+1 = 8, so from every point (card), 8 lines pass (8 pictures appear) and every line (picture) has 8 points (appears in 8 cards).
Here's a representation of the most famous finite projective (order-2) plane (geometry) with 7 points, known as Fano Plane, copied from Noelle Evans - Finite Geometry Problem Page
I was thinking of creating an image that explain how the above order-2 plane could be made a similar puzzle with 7 cards and 7 pictures, but then a link from the math.exchange twin question has exactly such a diagram: Dobble-et-la-geometrie-finie
For those who have trouble picturing the projective plane geometry with 57 points, there is a really nice, intuitive way to construct the game with 57 cards and 57 symbols (based on the answer by Yuval Filmus for this question):
For cards with 8 symbols, create a 7x7 grid of unique symbols.
Add an additional 8 symbols for the "slopes" from 0 to 6, plus one for infinity slope.
Each card is a line on the grid (7 symbols) plus one symbol from the slope set for the slope of the line. Lines have an offset (i.e. starting point on the left), and a slope (i.e. how many symbols to go up for each step right). When the line leaves the grid at the top, re-enter at the bottom. See this example figure (pictures from boardgamegeek) for two such cards:
In the example, I take one line with slope zero (red), and one with slope 1 (green). They intersect at exactly one common point (the owl).
This method ensures that any two cards have exactly one common symbol, because
If the slopes are different, then the lines will always intersect at exactly one point.
If the slopes are the same, then the lines will not intersect and there will be no common symbol from the grid. In this case, the slope symbol will be the same.
In this way, we can construct 7x7 cards (7 offsets and 7 slopes).
We can also construct seven additional cards from vertical lines through the grid (i.e. taking each column). For those, the infinity slope icon is used.
Because each card consists of seven symbols from the grid and exactly one "slope" symbol, we can create one additional card, which simply consists of all the 8 slope symbols.
This leaves us with 7x8 + 1 = 57 possible cards, and 7 x 7 + 8 = 57 required symbols.
(Naturally, this only works with a prime-number-sized grid (e.g. n=7). Otherwise, lines of different slope could have zero or more than one intersection if the slope is a divisor of the grid size.)
So there are k=55 cards containing m=8 pictures each from a pool of n pictures total.
We can restate the question 'How many pictures n do we need, so that we can construct a set of k cards with only one shared picture between any pair of cards?' equivalently by asking:
Given an n-dimensional vector space and the set of all vectors, which contain exactly m elements equal to one and all other zero, how big has n to be, so that we can find a set of k vectors, whose pairwise dot products are all equal to 1?
There are exactly (n choose m) possible vectors to build pairs from. So we at least need a big enough n so that (n choose m) >= k. This is just a lower bound, so for fulfilling the pairwise compatibility constraint we possibly need a much higher n.
Just for experimenting a bit i wrote a small Haskell program to calculate valid card sets:
Edit: I just realized after seeing Neil's and Gajet's solution, that the algorithm i use doesn't always find the best possible solution, so everything below isn't necessarily valid. I'll try to update my code soon.
module Main where
cardCandidates n m = cardCandidates' [] (n-m) m
cardCandidates' buildup 0 0 = [buildup]
cardCandidates' buildup zc oc
| zc>0 && oc>0 = zerorec ++ onerec
| zc>0 = zerorec
| otherwise = onerec
where zerorec = cardCandidates' (0:buildup) (zc-1) oc
onerec = cardCandidates' (1:buildup) zc (oc-1)
dot x y = sum $ zipWith (*) x y
compatible x y = dot x y == 1
compatibleCards = compatibleCards' []
compatibleCards' valid [] = valid
compatibleCards' valid (c:cs)
| all (compatible c) valid = compatibleCards' (c:valid) cs
| otherwise = compatibleCards' valid cs
legalCardSet n m = compatibleCards $ cardCandidates n m
main = mapM_ print [(n, length $ legalCardSet n m) | n<-[m..]]
where m = 8
The resulting maximum number of compatible cards for m=8 pictures per card for different number of pictures to choose from n for the first few n looks like this:
This brute force method doesn't get very far though because of combinatorial explosion. But i thought it might still be interesting.
Interestingly, it seems that for given m, k increases with n only up to a certain n, after which it stays constant.
This means, that for every number of pictures per card there is a certain number of pictures to choose from, that results in maximum possible number of legal cards. Adding more pictures to choose from past that optimal number doesn't increase the number of legal cards any further.
The first few optimal k's are:
Others have described the general framework for the design (finite projective plane) and shown how to generate finite projective planes of prime order. I would just like to fill in some gaps.
Finite projective planes can be generated for many different orders, but they are most straightforward in the case of prime order p. Then the integers modulo p form a finite field which can be used to describe coordinates for the points and lines in the plane. There are 3 different kinds of coordinates for points: (1,x,y), (0,1,x), and (0,0,1), where x and y can take on values from 0 to p-1. The 3 different kinds of points explains the formula p^2+p+1 for the number of points in the system. We can also describe lines with the same 3 different kinds of coordinates: [1,x,y], [0,1,x], and [0,0,1].
We compute whether a point and line are incident by whether the dot product of their coordinates is equal to 0 mod p. So for example the point (1,2,5) and the line [0,1,1] are incident when p=7 since 1*0+2*1+5*1 = 7 == 0 mod 7, but the point (1,3,3) and the line [1,2,6] are not incident since 1*1+3*2+3*6 = 25 != 0 mod 7.
Translating into the language of cards and pictures, that means the picture with coordinates (1,2,5) is contained in the card with coordinates [0,1,1], but the picture with coordinates (1,3,3) is not contained in the card with coordinates [1,2,6]. We can use this procedure to develop a complete list of cards and the pictures that they contain.
I think it's easier to think of pictures as points and cards as lines, but there's a duality in projective geometry between points and lines so it really doesn't matter. However, in what follows I will be using points for pictures and lines for cards.
The same construction works for any finite field. We know that there is a finite field of order q if and only if q=p^k, a prime power. The field is called GF(p^k) which stands for "Galois field". The fields are not as easy to construct in the prime power case as they are in the prime case.
Fortunately, the hard work has already been done and implemented in free software, namely Sage Math. To get a projective plane design of order 4, for example, just type
PG = designs.ProjectiveGeometryDesign(2,1,GF(4),point_coordinates=0)
PG.blocks()
and you'll obtain output that looks like
[[0,1,2,3,20], [0,4,8,12,16], [0,5,10,15,19], [0,6,11,13,17],
[0,7,9,14,18], [1,4,11,14,19], [1,5,9,13,16], [1,6,8,15,18],
[1,7,10,12,17], [2,4,9,15,17], [2,5,11,12,18], [2,6,10,14,16],
[2,7,8,13,19], [3,4,10,13,18], [3,5,8,14,17], [3,6,9,12,19],
[3,7,11,15,16], [4,5,6,7,20], [8,9,10,11,20], [12,13,14,15,20],
[16,17,18,19,20]]
I interpret the above as follows: there are 21 pictures labelled from 0 to 20. Each of the blocks (lines in projective geometry) tells me which pictures appears on a card. For example, the first card will have pictures 0, 1, 2, 3, and 20; the second card will have pictures 0, 4, 8, 12, and 16; and so on.
The system of order 7 can be generated by
PG = designs.ProjectiveGeometryDesign(2,1,GF(7),point_coordinates=0)
PG.blocks()
which generates the output
[[0, 1, 2, 3, 4, 5, 6, 56], [0, 7, 14, 21, 28, 35, 42, 49],
[0, 8, 16, 24, 32, 40, 48, 50], [0, 9, 18, 27, 29, 38, 47, 51],
[0, 10, 20, 23, 33, 36, 46, 52], [0, 11, 15,
26, 30, 41, 45, 53], [0, 12, 17, 22, 34, 39, 44, 54], [0, 13, 19, 25,
31, 37, 43, 55], [1, 7, 20, 26, 32, 38, 44, 55], [1, 8, 15, 22, 29, 36,
43, 49], [1, 9, 17, 25, 33, 41, 42, 50], [1, 10, 19, 21, 30, 39, 48,
51], [1, 11, 14, 24, 34, 37, 47, 52], [1, 12, 16, 27, 31, 35, 46, 53],
[1, 13, 18, 23, 28, 40, 45, 54], [2, 7, 19, 24, 29, 41, 46, 54], [2, 8,
14, 27, 33, 39, 45, 55], [2, 9, 16, 23, 30, 37, 44, 49], [2, 10, 18, 26,
34, 35, 43, 50], [2, 11, 20, 22, 31, 40, 42, 51], [2, 12, 15, 25, 28,
38, 48, 52], [2, 13, 17, 21, 32, 36, 47, 53], [3, 7, 18, 22, 33, 37, 48,
53], [3, 8, 20, 25, 30, 35, 47, 54], [3, 9, 15, 21, 34, 40, 46, 55], [3,
10, 17, 24, 31, 38, 45, 49], [3, 11, 19, 27, 28, 36, 44, 50], [3, 12,
14, 23, 32, 41, 43, 51], [3, 13, 16, 26, 29, 39, 42, 52], [4, 7, 17, 27,
30, 40, 43, 52], [4, 8, 19, 23, 34, 38, 42, 53], [4, 9, 14, 26, 31, 36,
48, 54], [4, 10, 16, 22, 28, 41, 47, 55], [4, 11, 18, 25, 32, 39, 46,
49], [4, 12, 20, 21, 29, 37, 45, 50], [4, 13, 15, 24, 33, 35, 44, 51],
[5, 7, 16, 25, 34, 36, 45, 51], [5, 8, 18, 21, 31, 41, 44, 52], [5, 9,
20, 24, 28, 39, 43, 53], [5, 10, 15, 27, 32, 37, 42, 54], [5, 11, 17,
23, 29, 35, 48, 55], [5, 12, 19, 26, 33, 40, 47, 49], [5, 13, 14, 22,
30, 38, 46, 50], [6, 7, 15, 23, 31, 39, 47, 50], [6, 8, 17, 26, 28, 37,
46, 51], [6, 9, 19, 22, 32, 35, 45, 52], [6, 10, 14, 25, 29, 40, 44,
53], [6, 11, 16, 21, 33, 38, 43, 54], [6, 12, 18, 24, 30, 36, 42, 55],
[6, 13, 20, 27, 34, 41, 48, 49], [7, 8, 9, 10, 11, 12, 13, 56], [14, 15,
16, 17, 18, 19, 20, 56], [21, 22, 23, 24, 25, 26, 27, 56], [28, 29, 30,
31, 32, 33, 34, 56], [35, 36, 37, 38, 39, 40, 41, 56], [42, 43, 44, 45,
46, 47, 48, 56], [49, 50, 51, 52, 53, 54, 55, 56]]
If you want up to 57 cards you can use GF(7). If you want 58 cards you'll have to use a larger field. Since 8 is a power of a prime, you could use GF(8). Note that the projective plane based on GF(8) will have 8^2 + 8 + 1 = 73 points and 73 lines. You can make 73 cards, but then just throw away 15 of them if you want a set of exactly 58 cards. If you want between 73 and 91 cards you could use GF(9), etc. There is no GF(10) because 10 is not a power of a prime. GF(11) is next, then GF(13), then GF(16) because 16=2^4, and so on.
By the way, I have a theory that the original Spot It deck uses 55, not 57, because they contracted a playing card manufacturer which was already tooled for decks of 55 cards (52 regular cards in a deck, plus two jokers and a title card).
I just found a way to do it with 57 or 58 pictures but now I have a very bad headache, I'll post the ruby code in 8-10 hours after I slept well! just a hint my my solution every 7 cards share same mark and total 56 cards can be constructed using my solution.
here is the code that generates all 57 cards that ypercube was talking about. it uses exactly 57 pictures, and sorry guy's I've written actual C++ code but knowing that vector <something> is an array containing values of type something it's easy to understand what this code does. and this code generates P^2+P+1 cards using P^2+P+1 pictures each containing P+1 picture and sharing only 1 picture in common, for every prime P value. which means we can have 7 cards using 7 pictures each having 3 pictures(for p=2), 13 cards using 13 pictures(for p=3), 31 cards using 31 pictures(for p=5), 57 cards for 57 pictures(for p=7) and so on...
#include <iostream>
#include <vector>
using namespace std;
vector <vector<int> > cards;
void createcards(int p)
{
cards.resize(0);
for (int i=0;i<p;i++)
{
cards.resize(cards.size()+1);
for(int j=0;j<p;j++)
{
cards.back().push_back(i*p+j);
}
cards.back().push_back(p*p+1);
}
for (int i=0;i<p;i++)
{
for(int j=0;j<p;j++)
{
cards.resize(cards.size()+1);
for(int k=0;k<p;k++)
{
cards.back().push_back(k*p+(j+i*k)%p);
}
cards.back().push_back(p*p+2+i);
}
}
cards.resize(cards.size()+1);
for (int i=0;i<p+1;i++)
cards.back().push_back(p*p+1+i);
}
void checkCards()
{
cout << "---------------------\n";
for(unsigned i=0;i<cards.size();i++)
{
for(unsigned j=0;j<cards[i].size();j++)
{
printf("%3d",cards[i][j]);
}
cout << "\n";
}
cout << "---------------------\n";
for(unsigned i=0;i<cards.size();i++)
{
for(unsigned j=i+1;j<cards.size();j++)
{
int sim = 0;
for(unsigned k=0;k<cards[i].size();k++)
for(unsigned l=0;l<cards[j].size();l++)
if (cards[i][k] == cards[j][l])
sim ++;
if (sim != 1)
cout << "there is a problem between cards : " << i << " " << j << "\n";
}
}
}
int main()
{
int p;
for(cin >> p; p!=0;cin>> p)
{
createcards(p);
checkCards();
}
}
again sorry for the delayed code.
Here's Gajet's solution in Python, since I find Python more readable. I have modified it so that it works with non-prime numbers as well. I have used Thies insight to generate some more easily understood display code.
from __future__ import print_function
from itertools import *
def create_cards(p):
for min_factor in range(2, 1 + int(p ** 0.5)):
if p % min_factor == 0:
break
else:
min_factor = p
cards = []
for i in range(p):
cards.append(set([i * p + j for j in range(p)] + [p * p]))
for i in range(min_factor):
for j in range(p):
cards.append(set([k * p + (j + i * k) % p
for k in range(p)] + [p * p + 1 + i]))
cards.append(set([p * p + i for i in range(min_factor + 1)]))
return cards, p * p + p + 1
def display_using_stars(cards, num_pictures):
for pictures_for_card in cards:
print("".join('*' if picture in pictures_for_card else ' '
for picture in range(num_pictures)))
def check_cards(cards):
for card, other_card in combinations(cards, 2):
if len(card & other_card) != 1:
print("Cards", sorted(card), "and", sorted(other_card),
"have intersection", sorted(card & other_card))
cards, num_pictures = create_cards(7)
display_using_stars(cards, num_pictures)
check_cards(cards)
With output:
*** *
*** *
****
* * * *
* * * *
* * * *
* * * *
* ** *
** * *
* * * *
* * * *
* * * *
****
Using the z3 theorem prover
Let P be the number of symbols per card. According to this article and ypercubeᵀᴹ's answer there are N = P**2 - P + 1 cards and symbols, respectively. A deck of cards can be represented with its incidence matrix which has a row for each card and a column for each possible symbol. Its (i,j) element is 1 if card i has symbol j on it. We only need to fill this matrix with these constraints in mind:
every element is either zero or one
the sum of each row is exactly P
the sum of each column is exactly P
any two rows must have exactly one symbol in common
That means N**2 variables and N**2 + 2*N + (N choose 2) constraints. It seems to be manageable in a not-so-long time with z3 for small inputs.
edit: Unfortunately P=8 seems to be too big for this method. I killed the process after 14 hour of computation time.
from z3 import *
from itertools import combinations
def is_prime_exponent(K):
return K > 1 and K not in 6 # next non-prime exponent is 10,
# but that is too big anyway
def transposed(rows):
return zip(*rows)
def spotit_z3(symbols_per_card):
K = symbols_per_card - 1
N = symbols_per_card ** 2 - symbols_per_card + 1
if not is_prime_exponent(K):
raise TypeError("Symbols per card must be a prime exponent plus one.")
constraints = []
# the rows of the incidence matrix
s = N.bit_length()
rows = [[BitVec("r%dc%d" % (r, c), s) for c in range(N)] for r in range(N)]
# every element must be either 1 or 0
constraints += [Or([elem == 1, elem == 0]) for row in rows for elem in row]
# sum of rows and cols must be exactly symbols_per_card
constraints += [Sum(row) == symbols_per_card for row in rows]
constraints += [Sum(col) == symbols_per_card for col in transposed(rows)]
# Any two rows must have exactly one symbol in common, in other words they
# differ in (symbols_per_card - 1) symbols, so their element-wise XOR will
# have 2 * (symbols_per_card - 1) ones.
D = 2 * (symbols_per_card - 1)
for row_a, row_b in combinations(rows, 2):
constraints += [Sum([a ^ b for a, b in zip(row_a, row_b)]) == D]
solver = Solver()
solver.add(constraints)
if solver.check() == unsat:
raise RuntimeError("Could not solve it :(")
# create the incidence matrix
model = solver.model()
return [[model[elem].as_long() for elem in row] for row in rows]
if __name__ == "__main__":
import sys
symbols_per_card = int(sys.argv[1])
incidence_matrix = spotit_z3(symbols_per_card)
for row in incidence_matrix:
print(row)
Results
$python spotit_z3.py 3
[0, 0, 1, 1, 0, 1, 0]
[0, 0, 0, 0, 1, 1, 1]
[0, 1, 0, 1, 0, 0, 1]
[1, 1, 0, 0, 0, 1, 0]
[0, 1, 1, 0, 1, 0, 0]
[1, 0, 0, 1, 1, 0, 0]
[1, 0, 1, 0, 0, 0, 1]
python spotit_z3.py 3 1.12s user 0.06s system 96% cpu 1.225 total
$ time python3 spotit_z3.py 4
[0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0]
[0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0]
[0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1]
[0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0]
[0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1]
[0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1]
[0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0]
[0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]
[1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0]
[1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]
[1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0]
python spotit_z3.py 4 664.62s user 0.15s system 99% cpu 11:04.88 total
$ time python3 spotit_z3.py 5
[1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]
[0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0]
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1]
[0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1]
[1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]
[0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0]
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1]
[1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0]
python spotit_z3.py 5 1162.72s user 20.34s system 99% cpu 19:43.39 total
$ time python3 spotit_z3.py 8
<I killed it after 14 hours of run time.>
I very much like this thread. I build this github python project with parts of this code here to draw custom cards as png (so one can order custom card games in the internet).
https://github.com/plagtag/ProjectiveGeometry-Game
I wrote an article about how to generate this kind of decks, with code in Perl. The code is not optimized but it's at least capable of generating decks of "reasonable" orders... and some more.
Here's an example with order 8, which has to consider a slightly more complicated underlying math, because 8 is not prime although a valid order for generating these kind of decks. See above or the article for a more detailed explanation, below if you just want to generate a slightly more difficult Spot-It :-)
$ time pg2 8
elements in field: 8
0. (1, 9, 17, 25, 33, 41, 49, 57, 65)
1. (0, 9, 10, 11, 12, 13, 14, 15, 16)
2. (2, 9, 18, 27, 36, 45, 54, 63, 72)
3. (6, 9, 22, 26, 37, 43, 56, 60, 71)
4. (7, 9, 23, 32, 34, 46, 52, 59, 69)
5. (8, 9, 24, 30, 35, 42, 55, 61, 68)
6. (3, 9, 19, 29, 39, 44, 50, 64, 70)
7. (4, 9, 20, 31, 38, 48, 53, 58, 67)
8. (5, 9, 21, 28, 40, 47, 51, 62, 66)
9. (0, 1, 2, 3, 4, 5, 6, 7, 8)
10. (1, 10, 18, 26, 34, 42, 50, 58, 66)
11. (1, 14, 22, 30, 38, 46, 54, 62, 70)
12. (1, 15, 23, 31, 39, 47, 55, 63, 71)
13. (1, 16, 24, 32, 40, 48, 56, 64, 72)
14. (1, 11, 19, 27, 35, 43, 51, 59, 67)
15. (1, 12, 20, 28, 36, 44, 52, 60, 68)
16. (1, 13, 21, 29, 37, 45, 53, 61, 69)
17. (0, 17, 18, 19, 20, 21, 22, 23, 24)
18. (2, 10, 17, 28, 35, 46, 53, 64, 71)
19. (6, 14, 17, 29, 34, 48, 51, 63, 68)
20. (7, 15, 17, 26, 40, 44, 54, 61, 67)
21. (8, 16, 17, 27, 38, 47, 50, 60, 69)
22. (3, 11, 17, 31, 37, 42, 52, 62, 72)
23. (4, 12, 17, 30, 39, 45, 56, 59, 66)
24. (5, 13, 17, 32, 36, 43, 55, 58, 70)
25. (0, 49, 50, 51, 52, 53, 54, 55, 56)
26. (3, 10, 20, 30, 40, 43, 49, 63, 69)
27. (2, 14, 21, 32, 39, 42, 49, 60, 67)
28. (8, 15, 18, 28, 37, 48, 49, 59, 70)
29. (6, 16, 19, 31, 36, 46, 49, 61, 66)
30. (5, 11, 23, 26, 38, 45, 49, 64, 68)
31. (7, 12, 22, 29, 35, 47, 49, 58, 72)
32. (4, 13, 24, 27, 34, 44, 49, 62, 71)
33. (0, 57, 58, 59, 60, 61, 62, 63, 64)
34. (4, 10, 19, 32, 37, 47, 54, 57, 68)
35. (5, 14, 18, 31, 35, 44, 56, 57, 69)
36. (2, 15, 24, 29, 38, 43, 52, 57, 66)
37. (3, 16, 22, 28, 34, 45, 55, 57, 67)
38. (7, 11, 21, 30, 36, 48, 50, 57, 71)
39. (6, 12, 23, 27, 40, 42, 53, 57, 70)
40. (8, 13, 20, 26, 39, 46, 51, 57, 72)
41. (0, 65, 66, 67, 68, 69, 70, 71, 72)
42. (5, 10, 22, 27, 39, 48, 52, 61, 65)
43. (3, 14, 24, 26, 36, 47, 53, 59, 65)
44. (6, 15, 20, 32, 35, 45, 50, 62, 65)
45. (2, 16, 23, 30, 37, 44, 51, 58, 65)
46. (4, 11, 18, 29, 40, 46, 55, 60, 65)
47. (8, 12, 21, 31, 34, 43, 54, 64, 65)
48. (7, 13, 19, 28, 38, 42, 56, 63, 65)
49. (0, 25, 26, 27, 28, 29, 30, 31, 32)
50. (6, 10, 21, 25, 38, 44, 55, 59, 72)
51. (8, 14, 19, 25, 40, 45, 52, 58, 71)
52. (4, 15, 22, 25, 36, 42, 51, 64, 69)
53. (7, 16, 18, 25, 39, 43, 53, 62, 68)
54. (2, 11, 20, 25, 34, 47, 56, 61, 70)
55. (5, 12, 24, 25, 37, 46, 50, 63, 67)
56. (3, 13, 23, 25, 35, 48, 54, 60, 66)
57. (0, 33, 34, 35, 36, 37, 38, 39, 40)
58. (7, 10, 24, 31, 33, 45, 51, 60, 70)
59. (4, 14, 23, 28, 33, 43, 50, 61, 72)
60. (3, 15, 21, 27, 33, 46, 56, 58, 68)
61. (5, 16, 20, 29, 33, 42, 54, 59, 71)
62. (8, 11, 22, 32, 33, 44, 53, 63, 66)
63. (2, 12, 19, 26, 33, 48, 55, 62, 69)
64. (6, 13, 18, 30, 33, 47, 52, 64, 67)
65. (0, 41, 42, 43, 44, 45, 46, 47, 48)
66. (8, 10, 23, 29, 36, 41, 56, 62, 67)
67. (7, 14, 20, 27, 37, 41, 55, 64, 66)
68. (5, 15, 19, 30, 34, 41, 53, 60, 72)
69. (4, 16, 21, 26, 35, 41, 52, 63, 70)
70. (6, 11, 24, 28, 39, 41, 54, 58, 69)
71. (3, 12, 18, 32, 38, 41, 51, 61, 71)
72. (2, 13, 22, 31, 40, 41, 50, 59, 68)
errors in check: 0
real 0m0.303s
user 0m0.200s
sys 0m0.016s
Each identifier from 0 to 72 can be read both as a card identifier and as a picture identifier. For example, the last row means that:
card 72 contains pictures 2, 13, 22, ..., 59, 68, AND
picture 72 appears in cards 2, 13, 22, ..., 59, and 68.
I wrote the following code to calculate the cards. The idea is to create the first card with n images on it. If the difference of every pair of image indexes is unique then the rest of the cards can be generated trivially, by increasing each index with the same value modulo m = n * n - n + 1
static public int[] Backtrack(int n)
{
int m = n * n - n + 1;
int[] Check = new int[m];
int C = 1;
int[] T = new int[n];
int _p = 2;
T[1] = 1;
if (n > 2) T[2] = 1;
else return T;
while (_p >= 2)
{
T[_p]++;
if (T[_p] == m)
{
_p--;
continue;
}
bool good = true;
C++;
for (int i = 0; i <= _p; i++)
{
for (int j = 0; j < i; j++)
{
int x = (T[i] - T[j] + m) % m;
if (Check[x] == C || Check[m - x] == C)//x cannot be equal to m-x as m is odd.
good = false;
Check[m - x] = C;
Check[x] = C;
}
}
if (good)
{
_p++;
if (_p == n)
{
_p--;
return T;
}
T[_p] = T[_p - 1];
}
}
return new int[] { };
}
static void Main(string[] args)
{
for (int N = 2; N < 11; N++)
{
var X = Backtrack(N);
if (X.Length > 0)
{
int K = N * N - N + 1;
Console.WriteLine("Cards: {0} Order {1}:", K, N - 1);
int C = 0;
for (int j = 0; j < K; j++)
{
Console.Write("Card {0:000}:", C++);
for (int i = 0; i < N; i++)
{
var t = (X[i] + j) % K;
if (j != 0 && Array.Exists(X, x => (x == t)))
Console.ForegroundColor = ConsoleColor.Green;
Console.Write("\t{0}", t);
Console.ResetColor();
}
Console.WriteLine();
}
}
}
}
output:
Cards: 3 Order 1:
Card 000: 0 1
Card 001: 1 2
Card 002: 2 0
Cards: 7 Order 2:
Card 000: 0 1 3
Card 001: 1 2 4
Card 002: 2 3 5
Card 003: 3 4 6
Card 004: 4 5 0
Card 005: 5 6 1
Card 006: 6 0 2
Cards: 13 Order 3:
Card 000: 0 1 3 9
Card 001: 1 2 4 10
Card 002: 2 3 5 11
Card 003: 3 4 6 12
Card 004: 4 5 7 0
Card 005: 5 6 8 1
Card 006: 6 7 9 2
Card 007: 7 8 10 3
Card 008: 8 9 11 4
Card 009: 9 10 12 5
Card 010: 10 11 0 6
Card 011: 11 12 1 7
Card 012: 12 0 2 8
Cards: 21 Order 4:
Card 000: 0 1 4 14 16
Card 001: 1 2 5 15 17
Card 002: 2 3 6 16 18
Card 003: 3 4 7 17 19
Card 004: 4 5 8 18 20
Card 005: 5 6 9 19 0
Card 006: 6 7 10 20 1
Card 007: 7 8 11 0 2
Card 008: 8 9 12 1 3
Card 009: 9 10 13 2 4
Card 010: 10 11 14 3 5
Card 011: 11 12 15 4 6
Card 012: 12 13 16 5 7
Card 013: 13 14 17 6 8
Card 014: 14 15 18 7 9
Card 015: 15 16 19 8 10
Card 016: 16 17 20 9 11
Card 017: 17 18 0 10 12
Card 018: 18 19 1 11 13
Card 019: 19 20 2 12 14
Card 020: 20 0 3 13 15
Cards: 31 Order 5:
Card 000: 0 1 3 8 12 18
Card 001: 1 2 4 9 13 19
Card 002: 2 3 5 10 14 20
Card 003: 3 4 6 11 15 21
Card 004: 4 5 7 12 16 22
Card 005: 5 6 8 13 17 23
Card 006: 6 7 9 14 18 24
Card 007: 7 8 10 15 19 25
Card 008: 8 9 11 16 20 26
Card 009: 9 10 12 17 21 27
Card 010: 10 11 13 18 22 28
Card 011: 11 12 14 19 23 29
Card 012: 12 13 15 20 24 30
Card 013: 13 14 16 21 25 0
Card 014: 14 15 17 22 26 1
Card 015: 15 16 18 23 27 2
Card 016: 16 17 19 24 28 3
Card 017: 17 18 20 25 29 4
Card 018: 18 19 21 26 30 5
Card 019: 19 20 22 27 0 6
Card 020: 20 21 23 28 1 7
Card 021: 21 22 24 29 2 8
Card 022: 22 23 25 30 3 9
Card 023: 23 24 26 0 4 10
Card 024: 24 25 27 1 5 11
Card 025: 25 26 28 2 6 12
Card 026: 26 27 29 3 7 13
Card 027: 27 28 30 4 8 14
Card 028: 28 29 0 5 9 15
Card 029: 29 30 1 6 10 16
Card 030: 30 0 2 7 11 17
Cards: 57 Order 7:
Card 000: 0 1 3 13 32 36 43 52
Card 001: 1 2 4 14 33 37 44 53
Card 002: 2 3 5 15 34 38 45 54
Card 003: 3 4 6 16 35 39 46 55
Card 004: 4 5 7 17 36 40 47 56
Card 005: 5 6 8 18 37 41 48 0
Card 006: 6 7 9 19 38 42 49 1
Card 007: 7 8 10 20 39 43 50 2
Card 008: 8 9 11 21 40 44 51 3
Card 009: 9 10 12 22 41 45 52 4
Card 010: 10 11 13 23 42 46 53 5
Card 011: 11 12 14 24 43 47 54 6
Card 012: 12 13 15 25 44 48 55 7
Card 013: 13 14 16 26 45 49 56 8
Card 014: 14 15 17 27 46 50 0 9
Card 015: 15 16 18 28 47 51 1 10
Card 016: 16 17 19 29 48 52 2 11
Card 017: 17 18 20 30 49 53 3 12
Card 018: 18 19 21 31 50 54 4 13
Card 019: 19 20 22 32 51 55 5 14
Card 020: 20 21 23 33 52 56 6 15
Card 021: 21 22 24 34 53 0 7 16
Card 022: 22 23 25 35 54 1 8 17
Card 023: 23 24 26 36 55 2 9 18
Card 024: 24 25 27 37 56 3 10 19
Card 025: 25 26 28 38 0 4 11 20
Card 026: 26 27 29 39 1 5 12 21
Card 027: 27 28 30 40 2 6 13 22
Card 028: 28 29 31 41 3 7 14 23
Card 029: 29 30 32 42 4 8 15 24
Card 030: 30 31 33 43 5 9 16 25
Card 031: 31 32 34 44 6 10 17 26
Card 032: 32 33 35 45 7 11 18 27
Card 033: 33 34 36 46 8 12 19 28
Card 034: 34 35 37 47 9 13 20 29
Card 035: 35 36 38 48 10 14 21 30
Card 036: 36 37 39 49 11 15 22 31
Card 037: 37 38 40 50 12 16 23 32
Card 038: 38 39 41 51 13 17 24 33
Card 039: 39 40 42 52 14 18 25 34
Card 040: 40 41 43 53 15 19 26 35
Card 041: 41 42 44 54 16 20 27 36
Card 042: 42 43 45 55 17 21 28 37
Card 043: 43 44 46 56 18 22 29 38
Card 044: 44 45 47 0 19 23 30 39
Card 045: 45 46 48 1 20 24 31 40
Card 046: 46 47 49 2 21 25 32 41
Card 047: 47 48 50 3 22 26 33 42
Card 048: 48 49 51 4 23 27 34 43
Card 049: 49 50 52 5 24 28 35 44
Card 050: 50 51 53 6 25 29 36 45
Card 051: 51 52 54 7 26 30 37 46
Card 052: 52 53 55 8 27 31 38 47
Card 053: 53 54 56 9 28 32 39 48
Card 054: 54 55 0 10 29 33 40 49
Card 055: 55 56 1 11 30 34 41 50
Card 056: 56 0 2 12 31 35 42 51
Cards: 73 Order 8:
Card 000: 0 1 3 7 15 31 36 54 63
Card 001: 1 2 4 8 16 32 37 55 64
Card 002: 2 3 5 9 17 33 38 56 65
Card 003: 3 4 6 10 18 34 39 57 66
Card 004: 4 5 7 11 19 35 40 58 67
Card 005: 5 6 8 12 20 36 41 59 68
Card 006: 6 7 9 13 21 37 42 60 69
Card 007: 7 8 10 14 22 38 43 61 70
Card 008: 8 9 11 15 23 39 44 62 71
Card 009: 9 10 12 16 24 40 45 63 72
Card 010: 10 11 13 17 25 41 46 64 0
Card 011: 11 12 14 18 26 42 47 65 1
Card 012: 12 13 15 19 27 43 48 66 2
Card 013: 13 14 16 20 28 44 49 67 3
Card 014: 14 15 17 21 29 45 50 68 4
Card 015: 15 16 18 22 30 46 51 69 5
Card 016: 16 17 19 23 31 47 52 70 6
Card 017: 17 18 20 24 32 48 53 71 7
Card 018: 18 19 21 25 33 49 54 72 8
Card 019: 19 20 22 26 34 50 55 0 9
Card 020: 20 21 23 27 35 51 56 1 10
Card 021: 21 22 24 28 36 52 57 2 11
Card 022: 22 23 25 29 37 53 58 3 12
Card 023: 23 24 26 30 38 54 59 4 13
Card 024: 24 25 27 31 39 55 60 5 14
Card 025: 25 26 28 32 40 56 61 6 15
Card 026: 26 27 29 33 41 57 62 7 16
Card 027: 27 28 30 34 42 58 63 8 17
Card 028: 28 29 31 35 43 59 64 9 18
Card 029: 29 30 32 36 44 60 65 10 19
Card 030: 30 31 33 37 45 61 66 11 20
Card 031: 31 32 34 38 46 62 67 12 21
Card 032: 32 33 35 39 47 63 68 13 22
Card 033: 33 34 36 40 48 64 69 14 23
Card 034: 34 35 37 41 49 65 70 15 24
Card 035: 35 36 38 42 50 66 71 16 25
Card 036: 36 37 39 43 51 67 72 17 26
Card 037: 37 38 40 44 52 68 0 18 27
Card 038: 38 39 41 45 53 69 1 19 28
Card 039: 39 40 42 46 54 70 2 20 29
Card 040: 40 41 43 47 55 71 3 21 30
Card 041: 41 42 44 48 56 72 4 22 31
Card 042: 42 43 45 49 57 0 5 23 32
Card 043: 43 44 46 50 58 1 6 24 33
Card 044: 44 45 47 51 59 2 7 25 34
Card 045: 45 46 48 52 60 3 8 26 35
Card 046: 46 47 49 53 61 4 9 27 36
Card 047: 47 48 50 54 62 5 10 28 37
Card 048: 48 49 51 55 63 6 11 29 38
Card 049: 49 50 52 56 64 7 12 30 39
Card 050: 50 51 53 57 65 8 13 31 40
Card 051: 51 52 54 58 66 9 14 32 41
Card 052: 52 53 55 59 67 10 15 33 42
Card 053: 53 54 56 60 68 11 16 34 43
Card 054: 54 55 57 61 69 12 17 35 44
Card 055: 55 56 58 62 70 13 18 36 45
Card 056: 56 57 59 63 71 14 19 37 46
Card 057: 57 58 60 64 72 15 20 38 47
Card 058: 58 59 61 65 0 16 21 39 48
Card 059: 59 60 62 66 1 17 22 40 49
Card 060: 60 61 63 67 2 18 23 41 50
Card 061: 61 62 64 68 3 19 24 42 51
Card 062: 62 63 65 69 4 20 25 43 52
Card 063: 63 64 66 70 5 21 26 44 53
Card 064: 64 65 67 71 6 22 27 45 54
Card 065: 65 66 68 72 7 23 28 46 55
Card 066: 66 67 69 0 8 24 29 47 56
Card 067: 67 68 70 1 9 25 30 48 57
Card 068: 68 69 71 2 10 26 31 49 58
Card 069: 69 70 72 3 11 27 32 50 59
Card 070: 70 71 0 4 12 28 33 51 60
Card 071: 71 72 1 5 13 29 34 52 61
Card 072: 72 0 2 6 14 30 35 53 62
Cards: 91 Order 9:
Card 000: 0 1 3 9 27 49 56 61 77 81
Card 001: 1 2 4 10 28 50 57 62 78 82
Card 002: 2 3 5 11 29 51 58 63 79 83
Card 003: 3 4 6 12 30 52 59 64 80 84
Card 004: 4 5 7 13 31 53 60 65 81 85
Card 005: 5 6 8 14 32 54 61 66 82 86
Card 006: 6 7 9 15 33 55 62 67 83 87
Card 007: 7 8 10 16 34 56 63 68 84 88
Card 008: 8 9 11 17 35 57 64 69 85 89
Card 009: 9 10 12 18 36 58 65 70 86 90
Card 010: 10 11 13 19 37 59 66 71 87 0
Card 011: 11 12 14 20 38 60 67 72 88 1
Card 012: 12 13 15 21 39 61 68 73 89 2
Card 013: 13 14 16 22 40 62 69 74 90 3
Card 014: 14 15 17 23 41 63 70 75 0 4
Card 015: 15 16 18 24 42 64 71 76 1 5
Card 016: 16 17 19 25 43 65 72 77 2 6
Card 017: 17 18 20 26 44 66 73 78 3 7
Card 018: 18 19 21 27 45 67 74 79 4 8
Card 019: 19 20 22 28 46 68 75 80 5 9
Card 020: 20 21 23 29 47 69 76 81 6 10
Card 021: 21 22 24 30 48 70 77 82 7 11
Card 022: 22 23 25 31 49 71 78 83 8 12
Card 023: 23 24 26 32 50 72 79 84 9 13
Card 024: 24 25 27 33 51 73 80 85 10 14
Card 025: 25 26 28 34 52 74 81 86 11 15
Card 026: 26 27 29 35 53 75 82 87 12 16
Card 027: 27 28 30 36 54 76 83 88 13 17
Card 028: 28 29 31 37 55 77 84 89 14 18
Card 029: 29 30 32 38 56 78 85 90 15 19
Card 030: 30 31 33 39 57 79 86 0 16 20
Card 031: 31 32 34 40 58 80 87 1 17 21
Card 032: 32 33 35 41 59 81 88 2 18 22
Card 033: 33 34 36 42 60 82 89 3 19 23
Card 034: 34 35 37 43 61 83 90 4 20 24
Card 035: 35 36 38 44 62 84 0 5 21 25
Card 036: 36 37 39 45 63 85 1 6 22 26
Card 037: 37 38 40 46 64 86 2 7 23 27
Card 038: 38 39 41 47 65 87 3 8 24 28
Card 039: 39 40 42 48 66 88 4 9 25 29
Card 040: 40 41 43 49 67 89 5 10 26 30
Card 041: 41 42 44 50 68 90 6 11 27 31
Card 042: 42 43 45 51 69 0 7 12 28 32
Card 043: 43 44 46 52 70 1 8 13 29 33
Card 044: 44 45 47 53 71 2 9 14 30 34
Card 045: 45 46 48 54 72 3 10 15 31 35
Card 046: 46 47 49 55 73 4 11 16 32 36
Card 047: 47 48 50 56 74 5 12 17 33 37
Card 048: 48 49 51 57 75 6 13 18 34 38
Card 049: 49 50 52 58 76 7 14 19 35 39
Card 050: 50 51 53 59 77 8 15 20 36 40
Card 051: 51 52 54 60 78 9 16 21 37 41
Card 052: 52 53 55 61 79 10 17 22 38 42
Card 053: 53 54 56 62 80 11 18 23 39 43
Card 054: 54 55 57 63 81 12 19 24 40 44
Card 055: 55 56 58 64 82 13 20 25 41 45
Card 056: 56 57 59 65 83 14 21 26 42 46
Card 057: 57 58 60 66 84 15 22 27 43 47
Card 058: 58 59 61 67 85 16 23 28 44 48
Card 059: 59 60 62 68 86 17 24 29 45 49
Card 060: 60 61 63 69 87 18 25 30 46 50
Card 061: 61 62 64 70 88 19 26 31 47 51
Card 062: 62 63 65 71 89 20 27 32 48 52
Card 063: 63 64 66 72 90 21 28 33 49 53
Card 064: 64 65 67 73 0 22 29 34 50 54
Card 065: 65 66 68 74 1 23 30 35 51 55
Card 066: 66 67 69 75 2 24 31 36 52 56
Card 067: 67 68 70 76 3 25 32 37 53 57
Card 068: 68 69 71 77 4 26 33 38 54 58
Card 069: 69 70 72 78 5 27 34 39 55 59
Card 070: 70 71 73 79 6 28 35 40 56 60
Card 071: 71 72 74 80 7 29 36 41 57 61
Card 072: 72 73 75 81 8 30 37 42 58 62
Card 073: 73 74 76 82 9 31 38 43 59 63
Card 074: 74 75 77 83 10 32 39 44 60 64
Card 075: 75 76 78 84 11 33 40 45 61 65
Card 076: 76 77 79 85 12 34 41 46 62 66
Card 077: 77 78 80 86 13 35 42 47 63 67
Card 078: 78 79 81 87 14 36 43 48 64 68
Card 079: 79 80 82 88 15 37 44 49 65 69
Card 080: 80 81 83 89 16 38 45 50 66 70
Card 081: 81 82 84 90 17 39 46 51 67 71
Card 082: 82 83 85 0 18 40 47 52 68 72
Card 083: 83 84 86 1 19 41 48 53 69 73
Card 084: 84 85 87 2 20 42 49 54 70 74
Card 085: 85 86 88 3 21 43 50 55 71 75
Card 086: 86 87 89 4 22 44 51 56 72 76
Card 087: 87 88 90 5 23 45 52 57 73 77
Card 088: 88 89 0 6 24 46 53 58 74 78
Card 089: 89 90 1 7 25 47 54 59 75 79
Card 090: 90 0 2 8 26 48 55 60 76 80

I have to convert one line from ruby to Qt C++

I need help from some one to convert the following line of code from ruby to qt c++:
KEY = %w(30 81 9F 30 0D 06 09 2A 86 48 86 F7 0D 01 01 01 05 00 03 81 8D 00).map{|s| s.hex}.pack('C*')
Here's what the Ruby code does:
Create an array of strings, ["30", "81", "9F", ... "8D", "00" ].
Convert each hexadecimal string in the array to an integer: [48, 129, 159, ... 141, 0]
Use Array#pack to turn the array into a single binary string of unsigned 8-bit integers.
If a simple C array will do:
unsigned char KEY[22] = { 0x30, 0x81, 0x9F, 0x30, 0x0D, 0x06... };
If you need a QByteArray:
QByteArray KEY("\x30\x81\x9F\x30\x0D\x06...", 22);
QByteArray key = QByteArray::fromHex(QByteArray("30 81 9F 30 0D 06 09 2A 86 48 86 F7 0D 01 01 01 05 00 03 81 8D 00").replace(' ', QString()));
Quick explanation:
QByteArray("30 81 9F 30 0D 06 09 2A 86 48 86 F7 0D 01 01 01 05 00 03 81 8D 00")
creates temporary QByteArray with your key as string
.replace(' ', QString())
removes all spaces in temporary QByteArray, so it contains only characters 0..F
QByteArray::fromHex()
converts hex-encoded QByteArray into QByteArray containing unsigned 8-bit integers (i.e. C++ char type). It means that it takes every pair of hex digits from original QByteArray ( for example "41") and converts it to integer ("41" will be converted to 65 = 4*16 + 1) and appends this value into new QByteArray.
If you need key as a "const char *" you can use QByteArray::constData() method, but you have to remember that the pointer returned by this method is valid only as long as original QByteArray is valid (quote from documentation: "as long as the byte array isn't reallocated or destroyed"). So if you need to store the key data, keep it as QByteArray or make a copy of const char * returned by constData().
char KEY[] = {
48, 129, 159, 48, 13, 6, 9, 42, 134, 72, 134, 247, 13, 1, 1, 1, 5, 0, 3, 129, 141, 0
};
The result is something slightly different, a flat array of byte values. It would certainly be possible to make an array of 1-character-string object references, but it would not be likely to be useful.

Resources